cmd/compile/internal/ssarewrite: split rewrites into packages
This change splits the rewrites out of ssacompile, and into a
package per .rules file. This will allow all the rules to be
built in parallel. Unfortunately the amd64 rules package dominates
so it doesn't split things out completely evenly, but it's a
start.
For #80409
[git-generate]
cd src/cmd/compile/internal/ssacompile
# Add one more function that's used by multiple rewrites back to the ssa package.
rf 'mv isConstZero IsConstZero'
rf 'mv IsConstZero ../ssa/rewrite.go'
cd ../ssa/_gen
sed -i -e 's/\bisConstZero(/ssa.IsConstZero(/g' *.rules
cd ../../ssacompile
rf '
mv divisible divisiblePass
mv divmod divmodPass
'
rf '
mv rewriteBlock386 RewriteBlock386
mv rewriteBlock386splitload RewriteBlock386splitload
mv rewriteBlockAMD64 RewriteBlockAMD64
mv rewriteBlockAMD64latelower RewriteBlockAMD64latelower
mv rewriteBlockAMD64splitload RewriteBlockAMD64splitload
mv rewriteBlockARM RewriteBlockARM
mv rewriteBlockARM64 RewriteBlockARM64
mv rewriteBlockARM64latelower RewriteBlockARM64latelower
mv rewriteBlockdec RewriteBlockdec
mv rewriteBlockdec64 RewriteBlockdec64
mv rewriteBlockdivisible RewriteBlockdivisible
mv rewriteBlockdivmod RewriteBlockdivmod
mv rewriteBlockgeneric RewriteBlockgeneric
mv rewriteBlockLOONG64 RewriteBlockLOONG64
mv rewriteBlockLOONG64latelower RewriteBlockLOONG64latelower
mv rewriteBlockMIPS RewriteBlockMIPS
mv rewriteBlockMIPS64 RewriteBlockMIPS64
mv rewriteBlockMIPS64latelower RewriteBlockMIPS64latelower
mv rewriteBlockPPC64 RewriteBlockPPC64
mv rewriteBlockPPC64latelower RewriteBlockPPC64latelower
mv rewriteBlockRISCV64 RewriteBlockRISCV64
mv rewriteBlockRISCV64latelower RewriteBlockRISCV64latelower
mv rewriteBlockS390X RewriteBlockS390X
mv rewriteBlockWasm RewriteBlockWasm
mv rewriteValue386 RewriteValue386
mv rewriteValue386splitload RewriteValue386splitload
mv rewriteValueAMD64 RewriteValueAMD64
mv rewriteValueAMD64latelower RewriteValueAMD64latelower
mv rewriteValueAMD64splitload RewriteValueAMD64splitload
mv rewriteValueARM RewriteValueARM
mv rewriteValueARM64 RewriteValueARM64
mv rewriteValueARM64latelower RewriteValueARM64latelower
mv rewriteValuedec RewriteValuedec
mv rewriteValuedec64 RewriteValuedec64
mv rewriteValuedivisible RewriteValuedivisible
mv rewriteValuedivmod RewriteValuedivmod
mv rewriteValuegeneric RewriteValuegeneric
mv rewriteValueLOONG64 RewriteValueLOONG64
mv rewriteValueLOONG64latelower RewriteValueLOONG64latelower
mv rewriteValueMIPS RewriteValueMIPS
mv rewriteValueMIPS64 RewriteValueMIPS64
mv rewriteValueMIPS64latelower RewriteValueMIPS64latelower
mv rewriteValuePPC64 RewriteValuePPC64
mv rewriteValuePPC64latelower RewriteValuePPC64latelower
mv rewriteValueRISCV64 RewriteValueRISCV64
mv rewriteValueRISCV64latelower RewriteValueRISCV64latelower
mv rewriteValueS390X RewriteValueS390X
mv rewriteValueWasm RewriteValueWasm
'
# Move the unexported helpers which have been paired with
# the rewrites that use them.
rf 'mv rewriteAMD64.go amd64_helpers.go ../ssarewrite/rewriteamd64/'
rf '
mv rewrite386.go ../ssarewrite/rewrite386/
mv rewrite386splitload.go ../ssarewrite/rewrite386splitload/
mv rewriteAMD64latelower.go ../ssarewrite/rewriteamd64latelower/
mv rewriteAMD64splitload.go ../ssarewrite/rewriteamd64splitload/
mv rewriteARM.go arm_helpers.go ../ssarewrite/rewritearm/
mv rewriteARM64.go arm64_helpers.go ../ssarewrite/rewritearm64/
mv rewriteARM64latelower.go arm64latelower_helpers.go ../ssarewrite/rewritearm64latelower/
mv rewritedec.go ../ssarewrite/rewritedec/
mv rewritedec64.go ../ssarewrite/rewritedec64/
mv rewritedivisible.go divisible_helpers.go ../ssarewrite/rewritedivisible/
mv rewritedivmod.go divmod_helpers.go ../ssarewrite/rewritedivmod/
mv rewritegeneric.go generic_helpers.go ../ssarewrite/rewritegeneric/
mv rewriteLOONG64.go ../ssarewrite/rewriteloong64/
mv rewriteLOONG64latelower.go ../ssarewrite/rewriteloong64latelower/
mv rewriteMIPS.go ../ssarewrite/rewritemips/
mv rewriteMIPS64.go ../ssarewrite/rewritemips64/
mv rewriteMIPS64latelower.go ../ssarewrite/rewritemips64latelower/
mv rewritePPC64.go ppc64_helpers.go ../ssarewrite/rewriteppc64/
mv rewritePPC64latelower.go ppc64latelower_helpers.go ../ssarewrite/rewriteppc64latelower/
mv rewriteRISCV64.go ../ssarewrite/rewriteriscv64/
mv rewriteRISCV64latelower.go ../ssarewrite/rewriteriscv64latelower/
mv rewriteS390X.go s390x_helpers.go ../ssarewrite/rewrites390x/
mv rewriteWasm.go ../ssarewrite/rewritewasm/
'
# Remove the redundant suffix in the rewrite name.
cd ../ssarewrite
for suffix in 386 386splitload \
AMD64 AMD64latelower \
AMD64splitload ARM \
ARM64 ARM64latelower \
LOONG64 LOONG64latelower \
MIPS MIPS64 \
MIPS64latelower PPC64 \
PPC64latelower RISCV64 \
RISCV64latelower S390X \
dec dec64 divisible \
divmod generic \
Wasm
do
cd rewrite$(echo $suffix | awk '{print tolower($1)}')
rf "
mv RewriteValue$suffix RewriteValue
mv RewriteBlock$suffix RewriteBlock
"
cd ..
done
# Ratchet generator and regenerate.
cd ../ssa/_gen
rf 'sub splitPhase var splitPhase = phase6Rewrites'
cd ..
go generate
# Tell dist to stub out the phase 1 rewrites in each of the new
# package we will create.
cd ../../../dist
rf 'sub ssaRewriteSplitPackages var ssaRewriteSplitPackages = true'
cd ../../simd/archsimd/_gen
sed -i 's/^var splitPhase = .*$/var splitPhase = phase6Rewrites/' \
simdgen/main.go wasmgen/main.go tmplgen/main.go
Change-Id: I542ae09fe3af1f43b8fcfca3ba068d9b6a6a6964
Reviewed-on: https://go-review.googlesource.com/c/go/+/808860
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: golang-scoped@luci-project-accounts.iam.gserviceaccount.com <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
diff --git a/src/cmd/compile/internal/ssa/_gen/generic.rules b/src/cmd/compile/internal/ssa/_gen/generic.rules
index 9dac73a..a520c9f 100644
--- a/src/cmd/compile/internal/ssa/_gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/_gen/generic.rules
@@ -981,22 +981,22 @@
// Don't Store zeros to cleared variables.
(Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& o >= 0 && t.Size() + o <= n && ssa.IsSamePtr(p1, p2)
=> mem
(Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p3)
&& ssa.Disjoint(op1, t1, p2, t2)
=> mem
(Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p4)
&& ssa.Disjoint(op1, t1, p2, t2)
&& ssa.Disjoint(op1, t1, p3, t3)
=> mem
(Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p5)
&& ssa.Disjoint(op1, t1, p2, t2)
&& ssa.Disjoint(op1, t1, p3, t3)
@@ -1398,12 +1398,12 @@
=> mem
(Store (SelectN [0] call:(StaticLECall ___)) x mem:(SelectN [1] call))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& isMalloc(call.Aux)
=> mem
(Store (OffPtr (SelectN [0] call:(StaticLECall ___))) x mem:(SelectN [1] call))
- && isConstZero(x)
+ && ssa.IsConstZero(x)
&& isMalloc(call.Aux)
=> mem
diff --git a/src/cmd/compile/internal/ssa/_gen/main.go b/src/cmd/compile/internal/ssa/_gen/main.go
index fbf9a4a..430ead0 100644
--- a/src/cmd/compile/internal/ssa/_gen/main.go
+++ b/src/cmd/compile/internal/ssa/_gen/main.go
@@ -29,7 +29,7 @@
// TODO: capitalize these types, so that we can more easily tell variable names
// apart from type names, and avoid awkward func parameters like "arch arch".
-var splitPhase = phase5Conv
+var splitPhase = phase6Rewrites
var splitTitle = identity
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 6e29c39..8f4201b 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -1491,3 +1491,19 @@
}
return fc
}
+
+func IsConstZero(v *Value) bool {
+ switch v.Op {
+ case ssaop.OpConstNil:
+ return true
+ case ssaop.OpConst64, ssaop.OpConst32, ssaop.OpConst16, ssaop.OpConst8, ssaop.OpConstBool, ssaop.OpConst32F, ssaop.OpConst64F:
+ return v.AuxInt == 0
+ case ssaop.OpStringMake, ssaop.OpIMake, ssaop.OpComplexMake:
+ return IsConstZero(v.Args[0]) && IsConstZero(v.Args[1])
+ case ssaop.OpSliceMake:
+ return IsConstZero(v.Args[0]) && IsConstZero(v.Args[1]) && IsConstZero(v.Args[2])
+ case ssaop.OpStringPtr, ssaop.OpStringLen, ssaop.OpSlicePtr, ssaop.OpSliceLen, ssaop.OpSliceCap, ssaop.OpITab, ssaop.OpIData, ssaop.OpComplexReal, ssaop.OpComplexImag:
+ return IsConstZero(v.Args[0])
+ }
+ return false
+}
diff --git a/src/cmd/compile/internal/ssacompile/compile.go b/src/cmd/compile/internal/ssacompile/compile.go
index b8f96e2..a31a97b 100644
--- a/src/cmd/compile/internal/ssacompile/compile.go
+++ b/src/cmd/compile/internal/ssacompile/compile.go
@@ -418,8 +418,8 @@
{Name: "gcse deadcode", Fn: deadcode, Required: true}, // clean out after cse and phiopt
{Name: "nilcheckelim", Fn: nilcheckelim},
{Name: "prove", Fn: prove},
- {Name: "divisible", Fn: divisible, Required: true},
- {Name: "divmod", Fn: divmod, Required: true},
+ {Name: "divisible", Fn: divisiblePass, Required: true},
+ {Name: "divmod", Fn: divmodPass, Required: true},
{Name: "middle opt", Fn: opt, Required: true},
{Name: "known bits", Fn: ssa.KnownBits},
{Name: "early fuse", Fn: fuseEarly},
diff --git a/src/cmd/compile/internal/ssacompile/config.go b/src/cmd/compile/internal/ssacompile/config.go
index 99ce52d..5c2c53a 100644
--- a/src/cmd/compile/internal/ssacompile/config.go
+++ b/src/cmd/compile/internal/ssacompile/config.go
@@ -9,6 +9,25 @@
"cmd/compile/internal/base"
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssa/ssaop"
+ "cmd/compile/internal/ssarewrite/rewrite386"
+ "cmd/compile/internal/ssarewrite/rewrite386splitload"
+ "cmd/compile/internal/ssarewrite/rewriteamd64"
+ "cmd/compile/internal/ssarewrite/rewriteamd64latelower"
+ "cmd/compile/internal/ssarewrite/rewriteamd64splitload"
+ "cmd/compile/internal/ssarewrite/rewritearm"
+ "cmd/compile/internal/ssarewrite/rewritearm64"
+ "cmd/compile/internal/ssarewrite/rewritearm64latelower"
+ "cmd/compile/internal/ssarewrite/rewriteloong64"
+ "cmd/compile/internal/ssarewrite/rewriteloong64latelower"
+ "cmd/compile/internal/ssarewrite/rewritemips"
+ "cmd/compile/internal/ssarewrite/rewritemips64"
+ "cmd/compile/internal/ssarewrite/rewritemips64latelower"
+ "cmd/compile/internal/ssarewrite/rewriteppc64"
+ "cmd/compile/internal/ssarewrite/rewriteppc64latelower"
+ "cmd/compile/internal/ssarewrite/rewriteriscv64"
+ "cmd/compile/internal/ssarewrite/rewriteriscv64latelower"
+ "cmd/compile/internal/ssarewrite/rewrites390x"
+ "cmd/compile/internal/ssarewrite/rewritewasm"
"cmd/internal/obj"
)
@@ -24,11 +43,11 @@
case "amd64":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockAMD64
- c.LowerValue = rewriteValueAMD64
- c.LateLowerBlock = rewriteBlockAMD64latelower
- c.LateLowerValue = rewriteValueAMD64latelower
- c.SplitLoad = rewriteValueAMD64splitload
+ c.LowerBlock = rewriteamd64.RewriteBlock
+ c.LowerValue = rewriteamd64.RewriteValue
+ c.LateLowerBlock = rewriteamd64latelower.RewriteBlock
+ c.LateLowerValue = rewriteamd64latelower.RewriteValue
+ c.SplitLoad = rewriteamd64splitload.RewriteValue
c.Registers = registersAMD64[:]
c.GpRegMask = gpRegMaskAMD64
c.FpRegMask = fpRegMaskAMD64
@@ -47,9 +66,9 @@
case "386":
c.PtrSize = 4
c.RegSize = 4
- c.LowerBlock = rewriteBlock386
- c.LowerValue = rewriteValue386
- c.SplitLoad = rewriteValue386splitload
+ c.LowerBlock = rewrite386.RewriteBlock
+ c.LowerValue = rewrite386.RewriteValue
+ c.SplitLoad = rewrite386splitload.RewriteValue
c.Registers = registers386[:]
c.GpRegMask = gpRegMask386
c.FpRegMask = fpRegMask386
@@ -62,8 +81,8 @@
case "arm":
c.PtrSize = 4
c.RegSize = 4
- c.LowerBlock = rewriteBlockARM
- c.LowerValue = rewriteValueARM
+ c.LowerBlock = rewritearm.RewriteBlock
+ c.LowerValue = rewritearm.RewriteValue
c.Registers = registersARM[:]
c.GpRegMask = gpRegMaskARM
c.FpRegMask = fpRegMaskARM
@@ -73,10 +92,10 @@
case "arm64":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockARM64
- c.LowerValue = rewriteValueARM64
- c.LateLowerBlock = rewriteBlockARM64latelower
- c.LateLowerValue = rewriteValueARM64latelower
+ c.LowerBlock = rewritearm64.RewriteBlock
+ c.LowerValue = rewritearm64.RewriteValue
+ c.LateLowerBlock = rewritearm64latelower.RewriteBlock
+ c.LateLowerValue = rewritearm64latelower.RewriteValue
c.Registers = registersARM64[:]
c.GpRegMask = gpRegMaskARM64
c.FpRegMask = fpRegMaskARM64
@@ -98,10 +117,10 @@
case "ppc64le":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockPPC64
- c.LowerValue = rewriteValuePPC64
- c.LateLowerBlock = rewriteBlockPPC64latelower
- c.LateLowerValue = rewriteValuePPC64latelower
+ c.LowerBlock = rewriteppc64.RewriteBlock
+ c.LowerValue = rewriteppc64.RewriteValue
+ c.LateLowerBlock = rewriteppc64latelower.RewriteBlock
+ c.LateLowerValue = rewriteppc64latelower.RewriteValue
c.Registers = registersPPC64[:]
c.GpRegMask = gpRegMaskPPC64
c.FpRegMask = fpRegMaskPPC64
@@ -126,10 +145,10 @@
case "mips64le":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockMIPS64
- c.LowerValue = rewriteValueMIPS64
- c.LateLowerBlock = rewriteBlockMIPS64latelower
- c.LateLowerValue = rewriteValueMIPS64latelower
+ c.LowerBlock = rewritemips64.RewriteBlock
+ c.LowerValue = rewritemips64.RewriteValue
+ c.LateLowerBlock = rewritemips64latelower.RewriteBlock
+ c.LateLowerValue = rewritemips64latelower.RewriteValue
c.Registers = registersMIPS64[:]
c.GpRegMask = gpRegMaskMIPS64
c.FpRegMask = fpRegMaskMIPS64
@@ -140,10 +159,10 @@
case "loong64":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockLOONG64
- c.LowerValue = rewriteValueLOONG64
- c.LateLowerBlock = rewriteBlockLOONG64latelower
- c.LateLowerValue = rewriteValueLOONG64latelower
+ c.LowerBlock = rewriteloong64.RewriteBlock
+ c.LowerValue = rewriteloong64.RewriteValue
+ c.LateLowerBlock = rewriteloong64latelower.RewriteBlock
+ c.LateLowerValue = rewriteloong64latelower.RewriteValue
c.Registers = registersLOONG64[:]
c.GpRegMask = gpRegMaskLOONG64
c.FpRegMask = fpRegMaskLOONG64
@@ -160,8 +179,8 @@
case "s390x":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockS390X
- c.LowerValue = rewriteValueS390X
+ c.LowerBlock = rewrites390x.RewriteBlock
+ c.LowerValue = rewrites390x.RewriteValue
c.Registers = registersS390X[:]
c.GpRegMask = gpRegMaskS390X
c.FpRegMask = fpRegMaskS390X
@@ -181,8 +200,8 @@
case "mipsle":
c.PtrSize = 4
c.RegSize = 4
- c.LowerBlock = rewriteBlockMIPS
- c.LowerValue = rewriteValueMIPS
+ c.LowerBlock = rewritemips.RewriteBlock
+ c.LowerValue = rewritemips.RewriteValue
c.Registers = registersMIPS[:]
c.GpRegMask = gpRegMaskMIPS
c.FpRegMask = fpRegMaskMIPS
@@ -193,10 +212,10 @@
case "riscv64":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockRISCV64
- c.LowerValue = rewriteValueRISCV64
- c.LateLowerBlock = rewriteBlockRISCV64latelower
- c.LateLowerValue = rewriteValueRISCV64latelower
+ c.LowerBlock = rewriteriscv64.RewriteBlock
+ c.LowerValue = rewriteriscv64.RewriteValue
+ c.LateLowerBlock = rewriteriscv64latelower.RewriteBlock
+ c.LateLowerValue = rewriteriscv64latelower.RewriteValue
c.Registers = registersRISCV64[:]
c.GpRegMask = gpRegMaskRISCV64
c.FpRegMask = fpRegMaskRISCV64
@@ -207,8 +226,8 @@
case "wasm":
c.PtrSize = 8
c.RegSize = 8
- c.LowerBlock = rewriteBlockWasm
- c.LowerValue = rewriteValueWasm
+ c.LowerBlock = rewritewasm.RewriteBlock
+ c.LowerValue = rewritewasm.RewriteValue
c.Registers = registersWasm[:]
c.GpRegMask = gpRegMaskWasm
c.FpRegMask = fpRegMaskWasm
diff --git a/src/cmd/compile/internal/ssacompile/decompose.go b/src/cmd/compile/internal/ssacompile/decompose.go
index 13f4773..88a5f93 100644
--- a/src/cmd/compile/internal/ssacompile/decompose.go
+++ b/src/cmd/compile/internal/ssacompile/decompose.go
@@ -10,6 +10,8 @@
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssa/ssaop"
+ "cmd/compile/internal/ssarewrite/rewritedec"
+ "cmd/compile/internal/ssarewrite/rewritedec64"
"cmd/compile/internal/types"
)
@@ -30,9 +32,9 @@
// Decompose other values
// Note: Leave dead values because we need to keep the original
// values around so the name component resolution below can still work.
- applyRewrite(f, rewriteBlockdec, rewriteValuedec, ssa.LeaveDeadValues)
+ applyRewrite(f, rewritedec.RewriteBlock, rewritedec.RewriteValue, ssa.LeaveDeadValues)
if f.Config.RegSize == 4 {
- applyRewrite(f, rewriteBlockdec64, rewriteValuedec64, ssa.LeaveDeadValues)
+ applyRewrite(f, rewritedec64.RewriteBlock, rewritedec64.RewriteValue, ssa.LeaveDeadValues)
}
// Split up named values into their components.
diff --git a/src/cmd/compile/internal/ssacompile/fuse_comparisons.go b/src/cmd/compile/internal/ssacompile/fuse_comparisons.go
index 614f369..4ae7481 100644
--- a/src/cmd/compile/internal/ssacompile/fuse_comparisons.go
+++ b/src/cmd/compile/internal/ssacompile/fuse_comparisons.go
@@ -181,7 +181,7 @@
case ssaop.OpNeq64, ssaop.OpNeq32, ssaop.OpNeq16, ssaop.OpNeq8:
// "x != 0" is equivalent to the unsigned "0 < x", and is its
// canonical form; see "prefer equalities with zero" in generic.rules.
- return isConstZero(v.Args[0]) || isConstZero(v.Args[1])
+ return ssa.IsConstZero(v.Args[0]) || ssa.IsConstZero(v.Args[1])
}
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/opt.go b/src/cmd/compile/internal/ssacompile/opt.go
index 0a0c5a5..28bb1a8 100644
--- a/src/cmd/compile/internal/ssacompile/opt.go
+++ b/src/cmd/compile/internal/ssacompile/opt.go
@@ -4,17 +4,22 @@
package ssacompile
-import "cmd/compile/internal/ssa"
+import (
+ "cmd/compile/internal/ssa"
+ "cmd/compile/internal/ssarewrite/rewritedivisible"
+ "cmd/compile/internal/ssarewrite/rewritedivmod"
+ "cmd/compile/internal/ssarewrite/rewritegeneric"
+)
// machine-independent optimization.
func opt(f *ssa.Func) {
- applyRewrite(f, rewriteBlockgeneric, rewriteValuegeneric, ssa.RemoveDeadValues)
+ applyRewrite(f, rewritegeneric.RewriteBlock, rewritegeneric.RewriteValue, ssa.RemoveDeadValues)
}
-func divisible(f *ssa.Func) {
- applyRewrite(f, rewriteBlockdivisible, rewriteValuedivisible, ssa.RemoveDeadValues)
+func divisiblePass(f *ssa.Func) {
+ applyRewrite(f, rewritedivisible.RewriteBlock, rewritedivisible.RewriteValue, ssa.RemoveDeadValues)
}
-func divmod(f *ssa.Func) {
- applyRewrite(f, rewriteBlockdivmod, rewriteValuedivmod, ssa.RemoveDeadValues)
+func divmodPass(f *ssa.Func) {
+ applyRewrite(f, rewritedivmod.RewriteBlock, rewritedivmod.RewriteValue, ssa.RemoveDeadValues)
}
diff --git a/src/cmd/compile/internal/ssacompile/sccp.go b/src/cmd/compile/internal/ssacompile/sccp.go
index 76afdf0..912d7ea 100644
--- a/src/cmd/compile/internal/ssacompile/sccp.go
+++ b/src/cmd/compile/internal/ssacompile/sccp.go
@@ -8,6 +8,7 @@
"cmd/compile/internal/ssa"
blockpkg "cmd/compile/internal/ssa/block"
"cmd/compile/internal/ssa/ssaop"
+ "cmd/compile/internal/ssarewrite/rewritegeneric"
)
// ----------------------------------------------------------------------------
@@ -366,7 +367,7 @@
// edges may still not be visited at this moment.
constValue := f.NewValue(val.Op, val.Type, f.Entry, val.Pos)
constValue.AddArgs(args...)
- matched := rewriteValuegeneric(constValue)
+ matched := rewritegeneric.RewriteValue(constValue)
if matched {
if isConst(constValue) {
return lattice{constant, constValue}
diff --git a/src/cmd/compile/internal/ssacompile/softfloat.go b/src/cmd/compile/internal/ssacompile/softfloat.go
index 915b81f..79a98b8 100644
--- a/src/cmd/compile/internal/ssacompile/softfloat.go
+++ b/src/cmd/compile/internal/ssacompile/softfloat.go
@@ -9,6 +9,7 @@
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssa/ssaop"
+ "cmd/compile/internal/ssarewrite/rewritedec64"
"cmd/compile/internal/types"
)
@@ -77,7 +78,7 @@
if newInt64 && f.Config.RegSize == 4 {
// On 32bit arch, decompose Uint64 introduced in the switch above.
decomposeBuiltin(f)
- applyRewrite(f, rewriteBlockdec64, rewriteValuedec64, ssa.RemoveDeadValues)
+ applyRewrite(f, rewritedec64.RewriteBlock, rewritedec64.RewriteValue, ssa.RemoveDeadValues)
}
}
diff --git a/src/cmd/compile/internal/ssacompile/rewrite386.go b/src/cmd/compile/internal/ssarewrite/rewrite386/rewrite386.go
similarity index 92%
rename from src/cmd/compile/internal/ssacompile/rewrite386.go
rename to src/cmd/compile/internal/ssarewrite/rewrite386/rewrite386.go
index de91fc1..4ab235c 100644
--- a/src/cmd/compile/internal/ssacompile/rewrite386.go
+++ b/src/cmd/compile/internal/ssarewrite/rewrite386/rewrite386.go
@@ -1,6 +1,6 @@
// Code generated from _gen/386.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewrite386
import "math"
import "cmd/compile/internal/types"
@@ -8,246 +8,246 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValue386(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.Op386ADCL:
- return rewriteValue386_Op386ADCL(v)
+ return rewriteValue_Op386ADCL(v)
case ssaop.Op386ADDL:
- return rewriteValue386_Op386ADDL(v)
+ return rewriteValue_Op386ADDL(v)
case ssaop.Op386ADDLcarry:
- return rewriteValue386_Op386ADDLcarry(v)
+ return rewriteValue_Op386ADDLcarry(v)
case ssaop.Op386ADDLconst:
- return rewriteValue386_Op386ADDLconst(v)
+ return rewriteValue_Op386ADDLconst(v)
case ssaop.Op386ADDLconstmodify:
- return rewriteValue386_Op386ADDLconstmodify(v)
+ return rewriteValue_Op386ADDLconstmodify(v)
case ssaop.Op386ADDLload:
- return rewriteValue386_Op386ADDLload(v)
+ return rewriteValue_Op386ADDLload(v)
case ssaop.Op386ADDLmodify:
- return rewriteValue386_Op386ADDLmodify(v)
+ return rewriteValue_Op386ADDLmodify(v)
case ssaop.Op386ADDSD:
- return rewriteValue386_Op386ADDSD(v)
+ return rewriteValue_Op386ADDSD(v)
case ssaop.Op386ADDSDload:
- return rewriteValue386_Op386ADDSDload(v)
+ return rewriteValue_Op386ADDSDload(v)
case ssaop.Op386ADDSS:
- return rewriteValue386_Op386ADDSS(v)
+ return rewriteValue_Op386ADDSS(v)
case ssaop.Op386ADDSSload:
- return rewriteValue386_Op386ADDSSload(v)
+ return rewriteValue_Op386ADDSSload(v)
case ssaop.Op386ANDL:
- return rewriteValue386_Op386ANDL(v)
+ return rewriteValue_Op386ANDL(v)
case ssaop.Op386ANDLconst:
- return rewriteValue386_Op386ANDLconst(v)
+ return rewriteValue_Op386ANDLconst(v)
case ssaop.Op386ANDLconstmodify:
- return rewriteValue386_Op386ANDLconstmodify(v)
+ return rewriteValue_Op386ANDLconstmodify(v)
case ssaop.Op386ANDLload:
- return rewriteValue386_Op386ANDLload(v)
+ return rewriteValue_Op386ANDLload(v)
case ssaop.Op386ANDLmodify:
- return rewriteValue386_Op386ANDLmodify(v)
+ return rewriteValue_Op386ANDLmodify(v)
case ssaop.Op386CMPB:
- return rewriteValue386_Op386CMPB(v)
+ return rewriteValue_Op386CMPB(v)
case ssaop.Op386CMPBconst:
- return rewriteValue386_Op386CMPBconst(v)
+ return rewriteValue_Op386CMPBconst(v)
case ssaop.Op386CMPBload:
- return rewriteValue386_Op386CMPBload(v)
+ return rewriteValue_Op386CMPBload(v)
case ssaop.Op386CMPL:
- return rewriteValue386_Op386CMPL(v)
+ return rewriteValue_Op386CMPL(v)
case ssaop.Op386CMPLconst:
- return rewriteValue386_Op386CMPLconst(v)
+ return rewriteValue_Op386CMPLconst(v)
case ssaop.Op386CMPLload:
- return rewriteValue386_Op386CMPLload(v)
+ return rewriteValue_Op386CMPLload(v)
case ssaop.Op386CMPW:
- return rewriteValue386_Op386CMPW(v)
+ return rewriteValue_Op386CMPW(v)
case ssaop.Op386CMPWconst:
- return rewriteValue386_Op386CMPWconst(v)
+ return rewriteValue_Op386CMPWconst(v)
case ssaop.Op386CMPWload:
- return rewriteValue386_Op386CMPWload(v)
+ return rewriteValue_Op386CMPWload(v)
case ssaop.Op386DIVSD:
- return rewriteValue386_Op386DIVSD(v)
+ return rewriteValue_Op386DIVSD(v)
case ssaop.Op386DIVSDload:
- return rewriteValue386_Op386DIVSDload(v)
+ return rewriteValue_Op386DIVSDload(v)
case ssaop.Op386DIVSS:
- return rewriteValue386_Op386DIVSS(v)
+ return rewriteValue_Op386DIVSS(v)
case ssaop.Op386DIVSSload:
- return rewriteValue386_Op386DIVSSload(v)
+ return rewriteValue_Op386DIVSSload(v)
case ssaop.Op386LEAL:
- return rewriteValue386_Op386LEAL(v)
+ return rewriteValue_Op386LEAL(v)
case ssaop.Op386LEAL1:
- return rewriteValue386_Op386LEAL1(v)
+ return rewriteValue_Op386LEAL1(v)
case ssaop.Op386LEAL2:
- return rewriteValue386_Op386LEAL2(v)
+ return rewriteValue_Op386LEAL2(v)
case ssaop.Op386LEAL4:
- return rewriteValue386_Op386LEAL4(v)
+ return rewriteValue_Op386LEAL4(v)
case ssaop.Op386LEAL8:
- return rewriteValue386_Op386LEAL8(v)
+ return rewriteValue_Op386LEAL8(v)
case ssaop.Op386LoweredPanicBoundsRC:
- return rewriteValue386_Op386LoweredPanicBoundsRC(v)
+ return rewriteValue_Op386LoweredPanicBoundsRC(v)
case ssaop.Op386LoweredPanicBoundsRR:
- return rewriteValue386_Op386LoweredPanicBoundsRR(v)
+ return rewriteValue_Op386LoweredPanicBoundsRR(v)
case ssaop.Op386LoweredPanicExtendRC:
- return rewriteValue386_Op386LoweredPanicExtendRC(v)
+ return rewriteValue_Op386LoweredPanicExtendRC(v)
case ssaop.Op386LoweredPanicExtendRR:
- return rewriteValue386_Op386LoweredPanicExtendRR(v)
+ return rewriteValue_Op386LoweredPanicExtendRR(v)
case ssaop.Op386MOVBLSX:
- return rewriteValue386_Op386MOVBLSX(v)
+ return rewriteValue_Op386MOVBLSX(v)
case ssaop.Op386MOVBLSXload:
- return rewriteValue386_Op386MOVBLSXload(v)
+ return rewriteValue_Op386MOVBLSXload(v)
case ssaop.Op386MOVBLZX:
- return rewriteValue386_Op386MOVBLZX(v)
+ return rewriteValue_Op386MOVBLZX(v)
case ssaop.Op386MOVBload:
- return rewriteValue386_Op386MOVBload(v)
+ return rewriteValue_Op386MOVBload(v)
case ssaop.Op386MOVBstore:
- return rewriteValue386_Op386MOVBstore(v)
+ return rewriteValue_Op386MOVBstore(v)
case ssaop.Op386MOVBstoreconst:
- return rewriteValue386_Op386MOVBstoreconst(v)
+ return rewriteValue_Op386MOVBstoreconst(v)
case ssaop.Op386MOVLload:
- return rewriteValue386_Op386MOVLload(v)
+ return rewriteValue_Op386MOVLload(v)
case ssaop.Op386MOVLstore:
- return rewriteValue386_Op386MOVLstore(v)
+ return rewriteValue_Op386MOVLstore(v)
case ssaop.Op386MOVLstoreconst:
- return rewriteValue386_Op386MOVLstoreconst(v)
+ return rewriteValue_Op386MOVLstoreconst(v)
case ssaop.Op386MOVSDconst:
- return rewriteValue386_Op386MOVSDconst(v)
+ return rewriteValue_Op386MOVSDconst(v)
case ssaop.Op386MOVSDload:
- return rewriteValue386_Op386MOVSDload(v)
+ return rewriteValue_Op386MOVSDload(v)
case ssaop.Op386MOVSDstore:
- return rewriteValue386_Op386MOVSDstore(v)
+ return rewriteValue_Op386MOVSDstore(v)
case ssaop.Op386MOVSSconst:
- return rewriteValue386_Op386MOVSSconst(v)
+ return rewriteValue_Op386MOVSSconst(v)
case ssaop.Op386MOVSSload:
- return rewriteValue386_Op386MOVSSload(v)
+ return rewriteValue_Op386MOVSSload(v)
case ssaop.Op386MOVSSstore:
- return rewriteValue386_Op386MOVSSstore(v)
+ return rewriteValue_Op386MOVSSstore(v)
case ssaop.Op386MOVWLSX:
- return rewriteValue386_Op386MOVWLSX(v)
+ return rewriteValue_Op386MOVWLSX(v)
case ssaop.Op386MOVWLSXload:
- return rewriteValue386_Op386MOVWLSXload(v)
+ return rewriteValue_Op386MOVWLSXload(v)
case ssaop.Op386MOVWLZX:
- return rewriteValue386_Op386MOVWLZX(v)
+ return rewriteValue_Op386MOVWLZX(v)
case ssaop.Op386MOVWload:
- return rewriteValue386_Op386MOVWload(v)
+ return rewriteValue_Op386MOVWload(v)
case ssaop.Op386MOVWstore:
- return rewriteValue386_Op386MOVWstore(v)
+ return rewriteValue_Op386MOVWstore(v)
case ssaop.Op386MOVWstoreconst:
- return rewriteValue386_Op386MOVWstoreconst(v)
+ return rewriteValue_Op386MOVWstoreconst(v)
case ssaop.Op386MULL:
- return rewriteValue386_Op386MULL(v)
+ return rewriteValue_Op386MULL(v)
case ssaop.Op386MULLconst:
- return rewriteValue386_Op386MULLconst(v)
+ return rewriteValue_Op386MULLconst(v)
case ssaop.Op386MULLload:
- return rewriteValue386_Op386MULLload(v)
+ return rewriteValue_Op386MULLload(v)
case ssaop.Op386MULSD:
- return rewriteValue386_Op386MULSD(v)
+ return rewriteValue_Op386MULSD(v)
case ssaop.Op386MULSDload:
- return rewriteValue386_Op386MULSDload(v)
+ return rewriteValue_Op386MULSDload(v)
case ssaop.Op386MULSS:
- return rewriteValue386_Op386MULSS(v)
+ return rewriteValue_Op386MULSS(v)
case ssaop.Op386MULSSload:
- return rewriteValue386_Op386MULSSload(v)
+ return rewriteValue_Op386MULSSload(v)
case ssaop.Op386NEGL:
- return rewriteValue386_Op386NEGL(v)
+ return rewriteValue_Op386NEGL(v)
case ssaop.Op386NOTL:
- return rewriteValue386_Op386NOTL(v)
+ return rewriteValue_Op386NOTL(v)
case ssaop.Op386ORL:
- return rewriteValue386_Op386ORL(v)
+ return rewriteValue_Op386ORL(v)
case ssaop.Op386ORLconst:
- return rewriteValue386_Op386ORLconst(v)
+ return rewriteValue_Op386ORLconst(v)
case ssaop.Op386ORLconstmodify:
- return rewriteValue386_Op386ORLconstmodify(v)
+ return rewriteValue_Op386ORLconstmodify(v)
case ssaop.Op386ORLload:
- return rewriteValue386_Op386ORLload(v)
+ return rewriteValue_Op386ORLload(v)
case ssaop.Op386ORLmodify:
- return rewriteValue386_Op386ORLmodify(v)
+ return rewriteValue_Op386ORLmodify(v)
case ssaop.Op386ROLB:
- return rewriteValue386_Op386ROLB(v)
+ return rewriteValue_Op386ROLB(v)
case ssaop.Op386ROLBconst:
- return rewriteValue386_Op386ROLBconst(v)
+ return rewriteValue_Op386ROLBconst(v)
case ssaop.Op386ROLL:
- return rewriteValue386_Op386ROLL(v)
+ return rewriteValue_Op386ROLL(v)
case ssaop.Op386ROLLconst:
- return rewriteValue386_Op386ROLLconst(v)
+ return rewriteValue_Op386ROLLconst(v)
case ssaop.Op386ROLW:
- return rewriteValue386_Op386ROLW(v)
+ return rewriteValue_Op386ROLW(v)
case ssaop.Op386ROLWconst:
- return rewriteValue386_Op386ROLWconst(v)
+ return rewriteValue_Op386ROLWconst(v)
case ssaop.Op386SARB:
- return rewriteValue386_Op386SARB(v)
+ return rewriteValue_Op386SARB(v)
case ssaop.Op386SARBconst:
- return rewriteValue386_Op386SARBconst(v)
+ return rewriteValue_Op386SARBconst(v)
case ssaop.Op386SARL:
- return rewriteValue386_Op386SARL(v)
+ return rewriteValue_Op386SARL(v)
case ssaop.Op386SARLconst:
- return rewriteValue386_Op386SARLconst(v)
+ return rewriteValue_Op386SARLconst(v)
case ssaop.Op386SARW:
- return rewriteValue386_Op386SARW(v)
+ return rewriteValue_Op386SARW(v)
case ssaop.Op386SARWconst:
- return rewriteValue386_Op386SARWconst(v)
+ return rewriteValue_Op386SARWconst(v)
case ssaop.Op386SBBL:
- return rewriteValue386_Op386SBBL(v)
+ return rewriteValue_Op386SBBL(v)
case ssaop.Op386SBBLcarrymask:
- return rewriteValue386_Op386SBBLcarrymask(v)
+ return rewriteValue_Op386SBBLcarrymask(v)
case ssaop.Op386SETA:
- return rewriteValue386_Op386SETA(v)
+ return rewriteValue_Op386SETA(v)
case ssaop.Op386SETAE:
- return rewriteValue386_Op386SETAE(v)
+ return rewriteValue_Op386SETAE(v)
case ssaop.Op386SETB:
- return rewriteValue386_Op386SETB(v)
+ return rewriteValue_Op386SETB(v)
case ssaop.Op386SETBE:
- return rewriteValue386_Op386SETBE(v)
+ return rewriteValue_Op386SETBE(v)
case ssaop.Op386SETEQ:
- return rewriteValue386_Op386SETEQ(v)
+ return rewriteValue_Op386SETEQ(v)
case ssaop.Op386SETG:
- return rewriteValue386_Op386SETG(v)
+ return rewriteValue_Op386SETG(v)
case ssaop.Op386SETGE:
- return rewriteValue386_Op386SETGE(v)
+ return rewriteValue_Op386SETGE(v)
case ssaop.Op386SETL:
- return rewriteValue386_Op386SETL(v)
+ return rewriteValue_Op386SETL(v)
case ssaop.Op386SETLE:
- return rewriteValue386_Op386SETLE(v)
+ return rewriteValue_Op386SETLE(v)
case ssaop.Op386SETNE:
- return rewriteValue386_Op386SETNE(v)
+ return rewriteValue_Op386SETNE(v)
case ssaop.Op386SHLL:
- return rewriteValue386_Op386SHLL(v)
+ return rewriteValue_Op386SHLL(v)
case ssaop.Op386SHLLconst:
- return rewriteValue386_Op386SHLLconst(v)
+ return rewriteValue_Op386SHLLconst(v)
case ssaop.Op386SHRB:
- return rewriteValue386_Op386SHRB(v)
+ return rewriteValue_Op386SHRB(v)
case ssaop.Op386SHRBconst:
- return rewriteValue386_Op386SHRBconst(v)
+ return rewriteValue_Op386SHRBconst(v)
case ssaop.Op386SHRL:
- return rewriteValue386_Op386SHRL(v)
+ return rewriteValue_Op386SHRL(v)
case ssaop.Op386SHRLconst:
- return rewriteValue386_Op386SHRLconst(v)
+ return rewriteValue_Op386SHRLconst(v)
case ssaop.Op386SHRW:
- return rewriteValue386_Op386SHRW(v)
+ return rewriteValue_Op386SHRW(v)
case ssaop.Op386SHRWconst:
- return rewriteValue386_Op386SHRWconst(v)
+ return rewriteValue_Op386SHRWconst(v)
case ssaop.Op386SUBL:
- return rewriteValue386_Op386SUBL(v)
+ return rewriteValue_Op386SUBL(v)
case ssaop.Op386SUBLcarry:
- return rewriteValue386_Op386SUBLcarry(v)
+ return rewriteValue_Op386SUBLcarry(v)
case ssaop.Op386SUBLconst:
- return rewriteValue386_Op386SUBLconst(v)
+ return rewriteValue_Op386SUBLconst(v)
case ssaop.Op386SUBLload:
- return rewriteValue386_Op386SUBLload(v)
+ return rewriteValue_Op386SUBLload(v)
case ssaop.Op386SUBLmodify:
- return rewriteValue386_Op386SUBLmodify(v)
+ return rewriteValue_Op386SUBLmodify(v)
case ssaop.Op386SUBSD:
- return rewriteValue386_Op386SUBSD(v)
+ return rewriteValue_Op386SUBSD(v)
case ssaop.Op386SUBSDload:
- return rewriteValue386_Op386SUBSDload(v)
+ return rewriteValue_Op386SUBSDload(v)
case ssaop.Op386SUBSS:
- return rewriteValue386_Op386SUBSS(v)
+ return rewriteValue_Op386SUBSS(v)
case ssaop.Op386SUBSSload:
- return rewriteValue386_Op386SUBSSload(v)
+ return rewriteValue_Op386SUBSSload(v)
case ssaop.Op386XORL:
- return rewriteValue386_Op386XORL(v)
+ return rewriteValue_Op386XORL(v)
case ssaop.Op386XORLconst:
- return rewriteValue386_Op386XORLconst(v)
+ return rewriteValue_Op386XORLconst(v)
case ssaop.Op386XORLconstmodify:
- return rewriteValue386_Op386XORLconstmodify(v)
+ return rewriteValue_Op386XORLconstmodify(v)
case ssaop.Op386XORLload:
- return rewriteValue386_Op386XORLload(v)
+ return rewriteValue_Op386XORLload(v)
case ssaop.Op386XORLmodify:
- return rewriteValue386_Op386XORLmodify(v)
+ return rewriteValue_Op386XORLmodify(v)
case ssaop.OpAdd16:
v.Op = ssaop.Op386ADDL
return true
@@ -276,7 +276,7 @@
v.Op = ssaop.Op386ADDL
return true
case ssaop.OpAddr:
- return rewriteValue386_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.Op386ANDL
return true
@@ -293,7 +293,7 @@
v.Op = ssaop.Op386AVGLU
return true
case ssaop.OpBswap16:
- return rewriteValue386_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
v.Op = ssaop.Op386BSWAPL
return true
@@ -310,7 +310,7 @@
v.Op = ssaop.Op386NOTL
return true
case ssaop.OpConst16:
- return rewriteValue386_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
v.Op = ssaop.Op386MOVLconst
return true
@@ -321,13 +321,13 @@
v.Op = ssaop.Op386MOVSDconst
return true
case ssaop.OpConst8:
- return rewriteValue386_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValue386_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValue386_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCtz16:
- return rewriteValue386_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.Op386BSFL
return true
@@ -341,7 +341,7 @@
v.Op = ssaop.Op386LoweredCtz64
return true
case ssaop.OpCtz8:
- return rewriteValue386_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.Op386BSFL
return true
@@ -385,23 +385,23 @@
v.Op = ssaop.Op386DIVSD
return true
case ssaop.OpDiv8:
- return rewriteValue386_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValue386_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValue386_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValue386_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValue386_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64F:
- return rewriteValue386_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValue386_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValue386_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValue386_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpGetCallerPC:
v.Op = ssaop.Op386LoweredGetCallerPC
return true
@@ -424,71 +424,71 @@
v.Op = ssaop.Op386CALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValue386_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValue386_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValue386_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValue386_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValue386_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValue386_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValue386_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValue386_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64F:
- return rewriteValue386_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq8:
- return rewriteValue386_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValue386_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValue386_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValue386_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValue386_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValue386_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValue386_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64F:
- return rewriteValue386_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess8:
- return rewriteValue386_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValue386_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValue386_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValue386_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValue386_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValue386_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValue386_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValue386_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValue386_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValue386_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValue386_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValue386_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh8x16:
- return rewriteValue386_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValue386_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValue386_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValue386_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMod16:
v.Op = ssaop.Op386MODW
return true
@@ -502,11 +502,11 @@
v.Op = ssaop.Op386MODLU
return true
case ssaop.OpMod8:
- return rewriteValue386_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValue386_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValue386_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.Op386MULL
return true
@@ -532,33 +532,33 @@
v.Op = ssaop.Op386NEGL
return true
case ssaop.OpNeg32F:
- return rewriteValue386_OpNeg32F(v)
+ return rewriteValue_OpNeg32F(v)
case ssaop.OpNeg64F:
- return rewriteValue386_OpNeg64F(v)
+ return rewriteValue_OpNeg64F(v)
case ssaop.OpNeg8:
v.Op = ssaop.Op386NEGL
return true
case ssaop.OpNeq16:
- return rewriteValue386_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValue386_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValue386_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64F:
- return rewriteValue386_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValue386_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
- return rewriteValue386_OpNeqB(v)
+ return rewriteValue_OpNeqB(v)
case ssaop.OpNeqPtr:
- return rewriteValue386_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.Op386LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValue386_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValue386_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.Op386ORL
return true
@@ -593,57 +593,57 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpRsh16Ux16:
- return rewriteValue386_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValue386_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValue386_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValue386_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValue386_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValue386_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValue386_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValue386_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValue386_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValue386_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValue386_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValue386_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValue386_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValue386_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValue386_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValue386_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValue386_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValue386_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValue386_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValue386_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValue386_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValue386_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValue386_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValue386_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValue386_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValue386_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.Op386MOVWLSX
return true
@@ -654,9 +654,9 @@
v.Op = ssaop.Op386MOVBLSX
return true
case ssaop.OpSignmask:
- return rewriteValue386_OpSignmask(v)
+ return rewriteValue_OpSignmask(v)
case ssaop.OpSlicemask:
- return rewriteValue386_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.Op386SQRTSD
return true
@@ -667,7 +667,7 @@
v.Op = ssaop.Op386CALLstatic
return true
case ssaop.OpStore:
- return rewriteValue386_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.Op386SUBL
return true
@@ -720,7 +720,7 @@
v.Op = ssaop.Op386XORL
return true
case ssaop.OpZero:
- return rewriteValue386_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.Op386MOVWLZX
return true
@@ -731,11 +731,11 @@
v.Op = ssaop.Op386MOVBLZX
return true
case ssaop.OpZeromask:
- return rewriteValue386_OpZeromask(v)
+ return rewriteValue_OpZeromask(v)
}
return false
}
-func rewriteValue386_Op386ADCL(v *ssa.Value) bool {
+func rewriteValue_Op386ADCL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -758,7 +758,7 @@
}
return false
}
-func rewriteValue386_Op386ADDL(v *ssa.Value) bool {
+func rewriteValue_Op386ADDL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDL x (MOVLconst <t> [c]))
@@ -950,7 +950,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLcarry(v *ssa.Value) bool {
+func rewriteValue_Op386ADDLcarry(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDLcarry x (MOVLconst [c]))
@@ -971,7 +971,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconst(v *ssa.Value) bool {
+func rewriteValue_Op386ADDLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDLconst [c] (ADDL x y))
// result: (LEAL1 [c] x y)
@@ -1144,7 +1144,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconstmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ADDLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1194,7 +1194,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLload(v *ssa.Value) bool {
+func rewriteValue_Op386ADDLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1247,7 +1247,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ADDLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1300,7 +1300,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSD(v *ssa.Value) bool {
+func rewriteValue_Op386ADDSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -1330,7 +1330,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSDload(v *ssa.Value) bool {
+func rewriteValue_Op386ADDSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1383,7 +1383,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSS(v *ssa.Value) bool {
+func rewriteValue_Op386ADDSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -1413,7 +1413,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSSload(v *ssa.Value) bool {
+func rewriteValue_Op386ADDSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1466,7 +1466,7 @@
}
return false
}
-func rewriteValue386_Op386ANDL(v *ssa.Value) bool {
+func rewriteValue_Op386ANDL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDL x (MOVLconst [c]))
@@ -1522,7 +1522,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconst(v *ssa.Value) bool {
+func rewriteValue_Op386ANDLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDLconst [c] (ANDLconst [d] x))
// result: (ANDLconst [c & d] x)
@@ -1576,7 +1576,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconstmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ANDLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1626,7 +1626,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLload(v *ssa.Value) bool {
+func rewriteValue_Op386ANDLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1679,7 +1679,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ANDLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1732,7 +1732,7 @@
}
return false
}
-func rewriteValue386_Op386CMPB(v *ssa.Value) bool {
+func rewriteValue_Op386CMPB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1827,7 +1827,7 @@
}
return false
}
-func rewriteValue386_Op386CMPBconst(v *ssa.Value) bool {
+func rewriteValue_Op386CMPBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPBconst (MOVLconst [x]) [y])
@@ -1998,7 +1998,7 @@
}
return false
}
-func rewriteValue386_Op386CMPBload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPBload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2021,7 +2021,7 @@
}
return false
}
-func rewriteValue386_Op386CMPL(v *ssa.Value) bool {
+func rewriteValue_Op386CMPL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2116,7 +2116,7 @@
}
return false
}
-func rewriteValue386_Op386CMPLconst(v *ssa.Value) bool {
+func rewriteValue_Op386CMPLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPLconst (MOVLconst [x]) [y])
@@ -2302,7 +2302,7 @@
}
return false
}
-func rewriteValue386_Op386CMPLload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2325,7 +2325,7 @@
}
return false
}
-func rewriteValue386_Op386CMPW(v *ssa.Value) bool {
+func rewriteValue_Op386CMPW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2420,7 +2420,7 @@
}
return false
}
-func rewriteValue386_Op386CMPWconst(v *ssa.Value) bool {
+func rewriteValue_Op386CMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPWconst (MOVLconst [x]) [y])
@@ -2591,7 +2591,7 @@
}
return false
}
-func rewriteValue386_Op386CMPWload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2614,7 +2614,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSD(v *ssa.Value) bool {
+func rewriteValue_Op386DIVSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -2641,7 +2641,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSDload(v *ssa.Value) bool {
+func rewriteValue_Op386DIVSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2694,7 +2694,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSS(v *ssa.Value) bool {
+func rewriteValue_Op386DIVSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -2721,7 +2721,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSSload(v *ssa.Value) bool {
+func rewriteValue_Op386DIVSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2774,7 +2774,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL(v *ssa.Value) bool {
+func rewriteValue_Op386LEAL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: ssa.Is32Bit(int64(c)+int64(d))
@@ -2933,7 +2933,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL1(v *ssa.Value) bool {
+func rewriteValue_Op386LEAL1(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
@@ -3114,7 +3114,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL2(v *ssa.Value) bool {
+func rewriteValue_Op386LEAL2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
@@ -3239,7 +3239,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL4(v *ssa.Value) bool {
+func rewriteValue_Op386LEAL4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
@@ -3348,7 +3348,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL8(v *ssa.Value) bool {
+func rewriteValue_Op386LEAL8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
@@ -3417,7 +3417,7 @@
}
return false
}
-func rewriteValue386_Op386LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_Op386LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVLconst [c]) mem)
@@ -3438,7 +3438,7 @@
}
return false
}
-func rewriteValue386_Op386LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_Op386LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3476,7 +3476,7 @@
}
return false
}
-func rewriteValue386_Op386LoweredPanicExtendRC(v *ssa.Value) bool {
+func rewriteValue_Op386LoweredPanicExtendRC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3502,7 +3502,7 @@
}
return false
}
-func rewriteValue386_Op386LoweredPanicExtendRR(v *ssa.Value) bool {
+func rewriteValue_Op386LoweredPanicExtendRR(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -3546,7 +3546,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSX(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBLSX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
@@ -3591,7 +3591,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSXload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBLSXload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3654,7 +3654,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLZX(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBLZX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
@@ -3695,7 +3695,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3779,7 +3779,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstore(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3883,7 +3883,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreconst(v *ssa.Value) bool {
+func rewriteValue_Op386MOVBstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3933,7 +3933,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVLload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4016,7 +4016,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstore(v *ssa.Value) bool {
+func rewriteValue_Op386MOVLstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4444,7 +4444,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconst(v *ssa.Value) bool {
+func rewriteValue_Op386MOVLstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4494,7 +4494,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDconst(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSDconst(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -4514,7 +4514,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4564,7 +4564,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstore(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4617,7 +4617,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSconst(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSSconst(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -4637,7 +4637,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSSload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4687,7 +4687,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstore(v *ssa.Value) bool {
+func rewriteValue_Op386MOVSSstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4740,7 +4740,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSX(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWLSX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
@@ -4785,7 +4785,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSXload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWLSXload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4848,7 +4848,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLZX(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWLZX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
@@ -4889,7 +4889,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWload(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4973,7 +4973,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstore(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5077,7 +5077,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconst(v *ssa.Value) bool {
+func rewriteValue_Op386MOVWstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5127,7 +5127,7 @@
}
return false
}
-func rewriteValue386_Op386MULL(v *ssa.Value) bool {
+func rewriteValue_Op386MULL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULL x (MOVLconst [c]))
@@ -5173,7 +5173,7 @@
}
return false
}
-func rewriteValue386_Op386MULLconst(v *ssa.Value) bool {
+func rewriteValue_Op386MULLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLconst [c] (MULLconst [d] x))
@@ -5591,7 +5591,7 @@
}
return false
}
-func rewriteValue386_Op386MULLload(v *ssa.Value) bool {
+func rewriteValue_Op386MULLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5644,7 +5644,7 @@
}
return false
}
-func rewriteValue386_Op386MULSD(v *ssa.Value) bool {
+func rewriteValue_Op386MULSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -5674,7 +5674,7 @@
}
return false
}
-func rewriteValue386_Op386MULSDload(v *ssa.Value) bool {
+func rewriteValue_Op386MULSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5727,7 +5727,7 @@
}
return false
}
-func rewriteValue386_Op386MULSS(v *ssa.Value) bool {
+func rewriteValue_Op386MULSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -5757,7 +5757,7 @@
}
return false
}
-func rewriteValue386_Op386MULSSload(v *ssa.Value) bool {
+func rewriteValue_Op386MULSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5810,7 +5810,7 @@
}
return false
}
-func rewriteValue386_Op386NEGL(v *ssa.Value) bool {
+func rewriteValue_Op386NEGL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGL (MOVLconst [c]))
// result: (MOVLconst [-c])
@@ -5825,7 +5825,7 @@
}
return false
}
-func rewriteValue386_Op386NOTL(v *ssa.Value) bool {
+func rewriteValue_Op386NOTL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NOTL (MOVLconst [c]))
// result: (MOVLconst [^c])
@@ -5840,7 +5840,7 @@
}
return false
}
-func rewriteValue386_Op386ORL(v *ssa.Value) bool {
+func rewriteValue_Op386ORL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORL x (MOVLconst [c]))
@@ -5896,7 +5896,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconst(v *ssa.Value) bool {
+func rewriteValue_Op386ORLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORLconst [c] x)
// cond: c==0
@@ -5936,7 +5936,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconstmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ORLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5986,7 +5986,7 @@
}
return false
}
-func rewriteValue386_Op386ORLload(v *ssa.Value) bool {
+func rewriteValue_Op386ORLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6039,7 +6039,7 @@
}
return false
}
-func rewriteValue386_Op386ORLmodify(v *ssa.Value) bool {
+func rewriteValue_Op386ORLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6092,7 +6092,7 @@
}
return false
}
-func rewriteValue386_Op386ROLB(v *ssa.Value) bool {
+func rewriteValue_Op386ROLB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLB x (MOVLconst [c]))
@@ -6110,7 +6110,7 @@
}
return false
}
-func rewriteValue386_Op386ROLBconst(v *ssa.Value) bool {
+func rewriteValue_Op386ROLBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLBconst [0] x)
// result: x
@@ -6124,7 +6124,7 @@
}
return false
}
-func rewriteValue386_Op386ROLL(v *ssa.Value) bool {
+func rewriteValue_Op386ROLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLL x (MOVLconst [c]))
@@ -6142,7 +6142,7 @@
}
return false
}
-func rewriteValue386_Op386ROLLconst(v *ssa.Value) bool {
+func rewriteValue_Op386ROLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLLconst [0] x)
// result: x
@@ -6156,7 +6156,7 @@
}
return false
}
-func rewriteValue386_Op386ROLW(v *ssa.Value) bool {
+func rewriteValue_Op386ROLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLW x (MOVLconst [c]))
@@ -6174,7 +6174,7 @@
}
return false
}
-func rewriteValue386_Op386ROLWconst(v *ssa.Value) bool {
+func rewriteValue_Op386ROLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLWconst [0] x)
// result: x
@@ -6188,7 +6188,7 @@
}
return false
}
-func rewriteValue386_Op386SARB(v *ssa.Value) bool {
+func rewriteValue_Op386SARB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARB x (MOVLconst [c]))
@@ -6206,7 +6206,7 @@
}
return false
}
-func rewriteValue386_Op386SARBconst(v *ssa.Value) bool {
+func rewriteValue_Op386SARBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARBconst x [0])
// result: x
@@ -6232,7 +6232,7 @@
}
return false
}
-func rewriteValue386_Op386SARL(v *ssa.Value) bool {
+func rewriteValue_Op386SARL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARL x (MOVLconst [c]))
@@ -6262,7 +6262,7 @@
}
return false
}
-func rewriteValue386_Op386SARLconst(v *ssa.Value) bool {
+func rewriteValue_Op386SARLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARLconst x [0])
// result: x
@@ -6288,7 +6288,7 @@
}
return false
}
-func rewriteValue386_Op386SARW(v *ssa.Value) bool {
+func rewriteValue_Op386SARW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARW x (MOVLconst [c]))
@@ -6306,7 +6306,7 @@
}
return false
}
-func rewriteValue386_Op386SARWconst(v *ssa.Value) bool {
+func rewriteValue_Op386SARWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARWconst x [0])
// result: x
@@ -6332,7 +6332,7 @@
}
return false
}
-func rewriteValue386_Op386SBBL(v *ssa.Value) bool {
+func rewriteValue_Op386SBBL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6352,7 +6352,7 @@
}
return false
}
-func rewriteValue386_Op386SBBLcarrymask(v *ssa.Value) bool {
+func rewriteValue_Op386SBBLcarrymask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SBBLcarrymask (FlagEQ))
// result: (MOVLconst [0])
@@ -6406,7 +6406,7 @@
}
return false
}
-func rewriteValue386_Op386SETA(v *ssa.Value) bool {
+func rewriteValue_Op386SETA(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETA (InvertFlags x))
// result: (SETB x)
@@ -6471,7 +6471,7 @@
}
return false
}
-func rewriteValue386_Op386SETAE(v *ssa.Value) bool {
+func rewriteValue_Op386SETAE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETAE (InvertFlags x))
// result: (SETBE x)
@@ -6536,7 +6536,7 @@
}
return false
}
-func rewriteValue386_Op386SETB(v *ssa.Value) bool {
+func rewriteValue_Op386SETB(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETB (InvertFlags x))
// result: (SETA x)
@@ -6601,7 +6601,7 @@
}
return false
}
-func rewriteValue386_Op386SETBE(v *ssa.Value) bool {
+func rewriteValue_Op386SETBE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETBE (InvertFlags x))
// result: (SETAE x)
@@ -6666,7 +6666,7 @@
}
return false
}
-func rewriteValue386_Op386SETEQ(v *ssa.Value) bool {
+func rewriteValue_Op386SETEQ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETEQ (InvertFlags x))
// result: (SETEQ x)
@@ -6731,7 +6731,7 @@
}
return false
}
-func rewriteValue386_Op386SETG(v *ssa.Value) bool {
+func rewriteValue_Op386SETG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETG (InvertFlags x))
// result: (SETL x)
@@ -6796,7 +6796,7 @@
}
return false
}
-func rewriteValue386_Op386SETGE(v *ssa.Value) bool {
+func rewriteValue_Op386SETGE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETGE (InvertFlags x))
// result: (SETLE x)
@@ -6861,7 +6861,7 @@
}
return false
}
-func rewriteValue386_Op386SETL(v *ssa.Value) bool {
+func rewriteValue_Op386SETL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETL (InvertFlags x))
// result: (SETG x)
@@ -6926,7 +6926,7 @@
}
return false
}
-func rewriteValue386_Op386SETLE(v *ssa.Value) bool {
+func rewriteValue_Op386SETLE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETLE (InvertFlags x))
// result: (SETGE x)
@@ -6991,7 +6991,7 @@
}
return false
}
-func rewriteValue386_Op386SETNE(v *ssa.Value) bool {
+func rewriteValue_Op386SETNE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETNE (InvertFlags x))
// result: (SETNE x)
@@ -7056,7 +7056,7 @@
}
return false
}
-func rewriteValue386_Op386SHLL(v *ssa.Value) bool {
+func rewriteValue_Op386SHLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHLL x (MOVLconst [c]))
@@ -7086,7 +7086,7 @@
}
return false
}
-func rewriteValue386_Op386SHLLconst(v *ssa.Value) bool {
+func rewriteValue_Op386SHLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHLLconst x [0])
// result: x
@@ -7100,7 +7100,7 @@
}
return false
}
-func rewriteValue386_Op386SHRB(v *ssa.Value) bool {
+func rewriteValue_Op386SHRB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRB x (MOVLconst [c]))
@@ -7137,7 +7137,7 @@
}
return false
}
-func rewriteValue386_Op386SHRBconst(v *ssa.Value) bool {
+func rewriteValue_Op386SHRBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRBconst x [0])
// result: x
@@ -7151,7 +7151,7 @@
}
return false
}
-func rewriteValue386_Op386SHRL(v *ssa.Value) bool {
+func rewriteValue_Op386SHRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRL x (MOVLconst [c]))
@@ -7181,7 +7181,7 @@
}
return false
}
-func rewriteValue386_Op386SHRLconst(v *ssa.Value) bool {
+func rewriteValue_Op386SHRLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRLconst x [0])
// result: x
@@ -7195,7 +7195,7 @@
}
return false
}
-func rewriteValue386_Op386SHRW(v *ssa.Value) bool {
+func rewriteValue_Op386SHRW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRW x (MOVLconst [c]))
@@ -7232,7 +7232,7 @@
}
return false
}
-func rewriteValue386_Op386SHRWconst(v *ssa.Value) bool {
+func rewriteValue_Op386SHRWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRWconst x [0])
// result: x
@@ -7246,7 +7246,7 @@
}
return false
}
-func rewriteValue386_Op386SUBL(v *ssa.Value) bool {
+func rewriteValue_Op386SUBL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7313,7 +7313,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLcarry(v *ssa.Value) bool {
+func rewriteValue_Op386SUBLcarry(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBLcarry x (MOVLconst [c]))
@@ -7331,7 +7331,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLconst(v *ssa.Value) bool {
+func rewriteValue_Op386SUBLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBLconst [c] x)
// cond: c==0
@@ -7356,7 +7356,7 @@
return true
}
}
-func rewriteValue386_Op386SUBLload(v *ssa.Value) bool {
+func rewriteValue_Op386SUBLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7409,7 +7409,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLmodify(v *ssa.Value) bool {
+func rewriteValue_Op386SUBLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7462,7 +7462,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSD(v *ssa.Value) bool {
+func rewriteValue_Op386SUBSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -7489,7 +7489,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSDload(v *ssa.Value) bool {
+func rewriteValue_Op386SUBSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7542,7 +7542,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSS(v *ssa.Value) bool {
+func rewriteValue_Op386SUBSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -7569,7 +7569,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSSload(v *ssa.Value) bool {
+func rewriteValue_Op386SUBSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7622,7 +7622,7 @@
}
return false
}
-func rewriteValue386_Op386XORL(v *ssa.Value) bool {
+func rewriteValue_Op386XORL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORL x (MOVLconst [c]))
@@ -7679,7 +7679,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconst(v *ssa.Value) bool {
+func rewriteValue_Op386XORLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORLconst [c] (XORLconst [d] x))
// result: (XORLconst [c ^ d] x)
@@ -7721,7 +7721,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconstmodify(v *ssa.Value) bool {
+func rewriteValue_Op386XORLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7771,7 +7771,7 @@
}
return false
}
-func rewriteValue386_Op386XORLload(v *ssa.Value) bool {
+func rewriteValue_Op386XORLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7824,7 +7824,7 @@
}
return false
}
-func rewriteValue386_Op386XORLmodify(v *ssa.Value) bool {
+func rewriteValue_Op386XORLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7877,7 +7877,7 @@
}
return false
}
-func rewriteValue386_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (LEAL {sym} base)
@@ -7890,7 +7890,7 @@
return true
}
}
-func rewriteValue386_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Bswap16 x)
// result: (ROLWconst [8] x)
@@ -7902,7 +7902,7 @@
return true
}
}
-func rewriteValue386_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [c])
// result: (MOVLconst [int32(c)])
for {
@@ -7912,7 +7912,7 @@
return true
}
}
-func rewriteValue386_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [c])
// result: (MOVLconst [int32(c)])
for {
@@ -7922,7 +7922,7 @@
return true
}
}
-func rewriteValue386_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [c])
// result: (MOVLconst [ssa.B2i32(c)])
for {
@@ -7932,7 +7932,7 @@
return true
}
}
-func rewriteValue386_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVLconst [0])
for {
@@ -7941,7 +7941,7 @@
return true
}
}
-func rewriteValue386_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7957,7 +7957,7 @@
return true
}
}
-func rewriteValue386_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7973,7 +7973,7 @@
return true
}
}
-func rewriteValue386_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7992,7 +7992,7 @@
return true
}
}
-func rewriteValue386_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8011,7 +8011,7 @@
return true
}
}
-func rewriteValue386_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8027,7 +8027,7 @@
return true
}
}
-func rewriteValue386_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8043,7 +8043,7 @@
return true
}
}
-func rewriteValue386_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8059,7 +8059,7 @@
return true
}
}
-func rewriteValue386_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8075,7 +8075,7 @@
return true
}
}
-func rewriteValue386_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8091,7 +8091,7 @@
return true
}
}
-func rewriteValue386_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8107,7 +8107,7 @@
return true
}
}
-func rewriteValue386_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8123,7 +8123,7 @@
return true
}
}
-func rewriteValue386_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8139,7 +8139,7 @@
return true
}
}
-func rewriteValue386_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil p)
@@ -8153,7 +8153,7 @@
return true
}
}
-func rewriteValue386_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8169,7 +8169,7 @@
return true
}
}
-func rewriteValue386_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8185,7 +8185,7 @@
return true
}
}
-func rewriteValue386_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8201,7 +8201,7 @@
return true
}
}
-func rewriteValue386_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8217,7 +8217,7 @@
return true
}
}
-func rewriteValue386_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8233,7 +8233,7 @@
return true
}
}
-func rewriteValue386_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8249,7 +8249,7 @@
return true
}
}
-func rewriteValue386_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8265,7 +8265,7 @@
return true
}
}
-func rewriteValue386_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8281,7 +8281,7 @@
return true
}
}
-func rewriteValue386_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8297,7 +8297,7 @@
return true
}
}
-func rewriteValue386_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8313,7 +8313,7 @@
return true
}
}
-func rewriteValue386_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8329,7 +8329,7 @@
return true
}
}
-func rewriteValue386_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8345,7 +8345,7 @@
return true
}
}
-func rewriteValue386_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8361,7 +8361,7 @@
return true
}
}
-func rewriteValue386_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8377,7 +8377,7 @@
return true
}
}
-func rewriteValue386_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8393,7 +8393,7 @@
return true
}
}
-func rewriteValue386_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8409,7 +8409,7 @@
return true
}
}
-func rewriteValue386_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8425,7 +8425,7 @@
return true
}
}
-func rewriteValue386_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -8500,7 +8500,7 @@
}
return false
}
-func rewriteValue386_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8540,7 +8540,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8582,7 +8582,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8624,7 +8624,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -8661,7 +8661,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8703,7 +8703,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8745,7 +8745,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8787,7 +8787,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -8824,7 +8824,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8866,7 +8866,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8908,7 +8908,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8950,7 +8950,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -8987,7 +8987,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9029,7 +9029,7 @@
}
return false
}
-func rewriteValue386_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9048,7 +9048,7 @@
return true
}
}
-func rewriteValue386_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9067,7 +9067,7 @@
return true
}
}
-func rewriteValue386_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9294,7 +9294,7 @@
}
return false
}
-func rewriteValue386_OpNeg32F(v *ssa.Value) bool {
+func rewriteValue_OpNeg32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9309,7 +9309,7 @@
return true
}
}
-func rewriteValue386_OpNeg64F(v *ssa.Value) bool {
+func rewriteValue_OpNeg64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9324,7 +9324,7 @@
return true
}
}
-func rewriteValue386_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9340,7 +9340,7 @@
return true
}
}
-func rewriteValue386_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9356,7 +9356,7 @@
return true
}
}
-func rewriteValue386_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9372,7 +9372,7 @@
return true
}
}
-func rewriteValue386_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9388,7 +9388,7 @@
return true
}
}
-func rewriteValue386_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9404,7 +9404,7 @@
return true
}
}
-func rewriteValue386_OpNeqB(v *ssa.Value) bool {
+func rewriteValue_OpNeqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9420,7 +9420,7 @@
return true
}
}
-func rewriteValue386_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9436,7 +9436,7 @@
return true
}
}
-func rewriteValue386_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORLconst [1] x)
@@ -9448,7 +9448,7 @@
return true
}
}
-func rewriteValue386_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr)
// result: (ADDLconst [int32(off)] ptr)
@@ -9461,7 +9461,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9503,7 +9503,7 @@
}
return false
}
-func rewriteValue386_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9545,7 +9545,7 @@
}
return false
}
-func rewriteValue386_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh16Ux64 x (Const64 [c]))
@@ -9582,7 +9582,7 @@
}
return false
}
-func rewriteValue386_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9624,7 +9624,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9667,7 +9667,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9710,7 +9710,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh16x64 x (Const64 [c]))
@@ -9749,7 +9749,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9792,7 +9792,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9834,7 +9834,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9876,7 +9876,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -9913,7 +9913,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9955,7 +9955,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9998,7 +9998,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10041,7 +10041,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -10080,7 +10080,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10123,7 +10123,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10165,7 +10165,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10207,7 +10207,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh8Ux64 x (Const64 [c]))
@@ -10244,7 +10244,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10286,7 +10286,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10329,7 +10329,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10372,7 +10372,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh8x64 x (Const64 [c]))
@@ -10411,7 +10411,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10454,7 +10454,7 @@
}
return false
}
-func rewriteValue386_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10475,7 +10475,7 @@
}
return false
}
-func rewriteValue386_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10497,7 +10497,7 @@
}
return false
}
-func rewriteValue386_OpSignmask(v *ssa.Value) bool {
+func rewriteValue_OpSignmask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SARLconst x [31])
@@ -10509,7 +10509,7 @@
return true
}
}
-func rewriteValue386_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -10525,7 +10525,7 @@
return true
}
}
-func rewriteValue386_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10606,7 +10606,7 @@
}
return false
}
-func rewriteValue386_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10839,7 +10839,7 @@
}
return false
}
-func rewriteValue386_OpZeromask(v *ssa.Value) bool {
+func rewriteValue_OpZeromask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Zeromask <t> x)
@@ -10858,7 +10858,7 @@
return true
}
}
-func rewriteBlock386(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.Block386EQ:
// match: (EQ (InvertFlags cmp) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/rewrite386splitload.go b/src/cmd/compile/internal/ssarewrite/rewrite386splitload/rewrite386splitload.go
similarity index 80%
rename from src/cmd/compile/internal/ssacompile/rewrite386splitload.go
rename to src/cmd/compile/internal/ssarewrite/rewrite386splitload/rewrite386splitload.go
index 49c8c61..4de3a7d 100644
--- a/src/cmd/compile/internal/ssacompile/rewrite386splitload.go
+++ b/src/cmd/compile/internal/ssarewrite/rewrite386splitload/rewrite386splitload.go
@@ -1,28 +1,28 @@
// Code generated from _gen/386splitload.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewrite386splitload
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValue386splitload(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.Op386CMPBconstload:
- return rewriteValue386splitload_Op386CMPBconstload(v)
+ return rewriteValue_Op386CMPBconstload(v)
case ssaop.Op386CMPBload:
- return rewriteValue386splitload_Op386CMPBload(v)
+ return rewriteValue_Op386CMPBload(v)
case ssaop.Op386CMPLconstload:
- return rewriteValue386splitload_Op386CMPLconstload(v)
+ return rewriteValue_Op386CMPLconstload(v)
case ssaop.Op386CMPLload:
- return rewriteValue386splitload_Op386CMPLload(v)
+ return rewriteValue_Op386CMPLload(v)
case ssaop.Op386CMPWconstload:
- return rewriteValue386splitload_Op386CMPWconstload(v)
+ return rewriteValue_Op386CMPWconstload(v)
case ssaop.Op386CMPWload:
- return rewriteValue386splitload_Op386CMPWload(v)
+ return rewriteValue_Op386CMPWload(v)
}
return false
}
-func rewriteValue386splitload_Op386CMPBconstload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPBconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -44,7 +44,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPBload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPBload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -66,7 +66,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPLconstload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPLconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -88,7 +88,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPLload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -110,7 +110,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPWconstload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPWconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -132,7 +132,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPWload(v *ssa.Value) bool {
+func rewriteValue_Op386CMPWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -154,6 +154,6 @@
return true
}
}
-func rewriteBlock386splitload(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/amd64_helpers.go b/src/cmd/compile/internal/ssarewrite/rewriteamd64/amd64_helpers.go
similarity index 98%
rename from src/cmd/compile/internal/ssacompile/amd64_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewriteamd64/amd64_helpers.go
index 7b95ceb..9357de1 100644
--- a/src/cmd/compile/internal/ssacompile/amd64_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteamd64/amd64_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewriteamd64
import (
"cmd/compile/internal/base"
diff --git a/src/cmd/compile/internal/ssacompile/rewriteAMD64.go b/src/cmd/compile/internal/ssarewrite/rewriteamd64/rewriteAMD64.go
similarity index 91%
rename from src/cmd/compile/internal/ssacompile/rewriteAMD64.go
rename to src/cmd/compile/internal/ssarewrite/rewriteamd64/rewriteAMD64.go
index 159dd7e..1394f56 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteamd64/rewriteAMD64.go
@@ -1,6 +1,6 @@
// Code generated from _gen/AMD64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteamd64
import "internal/buildcfg"
import "math"
@@ -11,7 +11,7 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueAMD64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAESDecryptLastRoundUint8x16:
v.Op = ssaop.OpAMD64VAESDECLAST128
@@ -56,3049 +56,3049 @@
v.Op = ssaop.OpAMD64VAESKEYGENASSIST128
return true
case ssaop.OpAMD64ADCQ:
- return rewriteValueAMD64_OpAMD64ADCQ(v)
+ return rewriteValue_OpAMD64ADCQ(v)
case ssaop.OpAMD64ADCQconst:
- return rewriteValueAMD64_OpAMD64ADCQconst(v)
+ return rewriteValue_OpAMD64ADCQconst(v)
case ssaop.OpAMD64ADDBconstmodify:
- return rewriteValueAMD64_OpAMD64ADDBconstmodify(v)
+ return rewriteValue_OpAMD64ADDBconstmodify(v)
case ssaop.OpAMD64ADDL:
- return rewriteValueAMD64_OpAMD64ADDL(v)
+ return rewriteValue_OpAMD64ADDL(v)
case ssaop.OpAMD64ADDLconst:
- return rewriteValueAMD64_OpAMD64ADDLconst(v)
+ return rewriteValue_OpAMD64ADDLconst(v)
case ssaop.OpAMD64ADDLconstmodify:
- return rewriteValueAMD64_OpAMD64ADDLconstmodify(v)
+ return rewriteValue_OpAMD64ADDLconstmodify(v)
case ssaop.OpAMD64ADDLload:
- return rewriteValueAMD64_OpAMD64ADDLload(v)
+ return rewriteValue_OpAMD64ADDLload(v)
case ssaop.OpAMD64ADDLlock:
- return rewriteValueAMD64_OpAMD64ADDLlock(v)
+ return rewriteValue_OpAMD64ADDLlock(v)
case ssaop.OpAMD64ADDLmodify:
- return rewriteValueAMD64_OpAMD64ADDLmodify(v)
+ return rewriteValue_OpAMD64ADDLmodify(v)
case ssaop.OpAMD64ADDQ:
- return rewriteValueAMD64_OpAMD64ADDQ(v)
+ return rewriteValue_OpAMD64ADDQ(v)
case ssaop.OpAMD64ADDQcarry:
- return rewriteValueAMD64_OpAMD64ADDQcarry(v)
+ return rewriteValue_OpAMD64ADDQcarry(v)
case ssaop.OpAMD64ADDQconst:
- return rewriteValueAMD64_OpAMD64ADDQconst(v)
+ return rewriteValue_OpAMD64ADDQconst(v)
case ssaop.OpAMD64ADDQconstmodify:
- return rewriteValueAMD64_OpAMD64ADDQconstmodify(v)
+ return rewriteValue_OpAMD64ADDQconstmodify(v)
case ssaop.OpAMD64ADDQload:
- return rewriteValueAMD64_OpAMD64ADDQload(v)
+ return rewriteValue_OpAMD64ADDQload(v)
case ssaop.OpAMD64ADDQlock:
- return rewriteValueAMD64_OpAMD64ADDQlock(v)
+ return rewriteValue_OpAMD64ADDQlock(v)
case ssaop.OpAMD64ADDQmodify:
- return rewriteValueAMD64_OpAMD64ADDQmodify(v)
+ return rewriteValue_OpAMD64ADDQmodify(v)
case ssaop.OpAMD64ADDSD:
- return rewriteValueAMD64_OpAMD64ADDSD(v)
+ return rewriteValue_OpAMD64ADDSD(v)
case ssaop.OpAMD64ADDSDload:
- return rewriteValueAMD64_OpAMD64ADDSDload(v)
+ return rewriteValue_OpAMD64ADDSDload(v)
case ssaop.OpAMD64ADDSS:
- return rewriteValueAMD64_OpAMD64ADDSS(v)
+ return rewriteValue_OpAMD64ADDSS(v)
case ssaop.OpAMD64ADDSSload:
- return rewriteValueAMD64_OpAMD64ADDSSload(v)
+ return rewriteValue_OpAMD64ADDSSload(v)
case ssaop.OpAMD64ADDWconstmodify:
- return rewriteValueAMD64_OpAMD64ADDWconstmodify(v)
+ return rewriteValue_OpAMD64ADDWconstmodify(v)
case ssaop.OpAMD64ANDBconstmodify:
- return rewriteValueAMD64_OpAMD64ANDBconstmodify(v)
+ return rewriteValue_OpAMD64ANDBconstmodify(v)
case ssaop.OpAMD64ANDL:
- return rewriteValueAMD64_OpAMD64ANDL(v)
+ return rewriteValue_OpAMD64ANDL(v)
case ssaop.OpAMD64ANDLconst:
- return rewriteValueAMD64_OpAMD64ANDLconst(v)
+ return rewriteValue_OpAMD64ANDLconst(v)
case ssaop.OpAMD64ANDLconstmodify:
- return rewriteValueAMD64_OpAMD64ANDLconstmodify(v)
+ return rewriteValue_OpAMD64ANDLconstmodify(v)
case ssaop.OpAMD64ANDLload:
- return rewriteValueAMD64_OpAMD64ANDLload(v)
+ return rewriteValue_OpAMD64ANDLload(v)
case ssaop.OpAMD64ANDLmodify:
- return rewriteValueAMD64_OpAMD64ANDLmodify(v)
+ return rewriteValue_OpAMD64ANDLmodify(v)
case ssaop.OpAMD64ANDNL:
- return rewriteValueAMD64_OpAMD64ANDNL(v)
+ return rewriteValue_OpAMD64ANDNL(v)
case ssaop.OpAMD64ANDNQ:
- return rewriteValueAMD64_OpAMD64ANDNQ(v)
+ return rewriteValue_OpAMD64ANDNQ(v)
case ssaop.OpAMD64ANDQ:
- return rewriteValueAMD64_OpAMD64ANDQ(v)
+ return rewriteValue_OpAMD64ANDQ(v)
case ssaop.OpAMD64ANDQconst:
- return rewriteValueAMD64_OpAMD64ANDQconst(v)
+ return rewriteValue_OpAMD64ANDQconst(v)
case ssaop.OpAMD64ANDQconstmodify:
- return rewriteValueAMD64_OpAMD64ANDQconstmodify(v)
+ return rewriteValue_OpAMD64ANDQconstmodify(v)
case ssaop.OpAMD64ANDQload:
- return rewriteValueAMD64_OpAMD64ANDQload(v)
+ return rewriteValue_OpAMD64ANDQload(v)
case ssaop.OpAMD64ANDQmodify:
- return rewriteValueAMD64_OpAMD64ANDQmodify(v)
+ return rewriteValue_OpAMD64ANDQmodify(v)
case ssaop.OpAMD64ANDWconstmodify:
- return rewriteValueAMD64_OpAMD64ANDWconstmodify(v)
+ return rewriteValue_OpAMD64ANDWconstmodify(v)
case ssaop.OpAMD64AddTupleFirst32:
- return rewriteValueAMD64_OpAMD64AddTupleFirst32(v)
+ return rewriteValue_OpAMD64AddTupleFirst32(v)
case ssaop.OpAMD64AddTupleFirst64:
- return rewriteValueAMD64_OpAMD64AddTupleFirst64(v)
+ return rewriteValue_OpAMD64AddTupleFirst64(v)
case ssaop.OpAMD64BSFQ:
- return rewriteValueAMD64_OpAMD64BSFQ(v)
+ return rewriteValue_OpAMD64BSFQ(v)
case ssaop.OpAMD64BSWAPL:
- return rewriteValueAMD64_OpAMD64BSWAPL(v)
+ return rewriteValue_OpAMD64BSWAPL(v)
case ssaop.OpAMD64BSWAPQ:
- return rewriteValueAMD64_OpAMD64BSWAPQ(v)
+ return rewriteValue_OpAMD64BSWAPQ(v)
case ssaop.OpAMD64BTCQconst:
- return rewriteValueAMD64_OpAMD64BTCQconst(v)
+ return rewriteValue_OpAMD64BTCQconst(v)
case ssaop.OpAMD64BTLconst:
- return rewriteValueAMD64_OpAMD64BTLconst(v)
+ return rewriteValue_OpAMD64BTLconst(v)
case ssaop.OpAMD64BTQconst:
- return rewriteValueAMD64_OpAMD64BTQconst(v)
+ return rewriteValue_OpAMD64BTQconst(v)
case ssaop.OpAMD64BTRQconst:
- return rewriteValueAMD64_OpAMD64BTRQconst(v)
+ return rewriteValue_OpAMD64BTRQconst(v)
case ssaop.OpAMD64BTSQconst:
- return rewriteValueAMD64_OpAMD64BTSQconst(v)
+ return rewriteValue_OpAMD64BTSQconst(v)
case ssaop.OpAMD64CMOVLCC:
- return rewriteValueAMD64_OpAMD64CMOVLCC(v)
+ return rewriteValue_OpAMD64CMOVLCC(v)
case ssaop.OpAMD64CMOVLCS:
- return rewriteValueAMD64_OpAMD64CMOVLCS(v)
+ return rewriteValue_OpAMD64CMOVLCS(v)
case ssaop.OpAMD64CMOVLEQ:
- return rewriteValueAMD64_OpAMD64CMOVLEQ(v)
+ return rewriteValue_OpAMD64CMOVLEQ(v)
case ssaop.OpAMD64CMOVLGE:
- return rewriteValueAMD64_OpAMD64CMOVLGE(v)
+ return rewriteValue_OpAMD64CMOVLGE(v)
case ssaop.OpAMD64CMOVLGT:
- return rewriteValueAMD64_OpAMD64CMOVLGT(v)
+ return rewriteValue_OpAMD64CMOVLGT(v)
case ssaop.OpAMD64CMOVLHI:
- return rewriteValueAMD64_OpAMD64CMOVLHI(v)
+ return rewriteValue_OpAMD64CMOVLHI(v)
case ssaop.OpAMD64CMOVLLE:
- return rewriteValueAMD64_OpAMD64CMOVLLE(v)
+ return rewriteValue_OpAMD64CMOVLLE(v)
case ssaop.OpAMD64CMOVLLS:
- return rewriteValueAMD64_OpAMD64CMOVLLS(v)
+ return rewriteValue_OpAMD64CMOVLLS(v)
case ssaop.OpAMD64CMOVLLT:
- return rewriteValueAMD64_OpAMD64CMOVLLT(v)
+ return rewriteValue_OpAMD64CMOVLLT(v)
case ssaop.OpAMD64CMOVLNE:
- return rewriteValueAMD64_OpAMD64CMOVLNE(v)
+ return rewriteValue_OpAMD64CMOVLNE(v)
case ssaop.OpAMD64CMOVQCC:
- return rewriteValueAMD64_OpAMD64CMOVQCC(v)
+ return rewriteValue_OpAMD64CMOVQCC(v)
case ssaop.OpAMD64CMOVQCS:
- return rewriteValueAMD64_OpAMD64CMOVQCS(v)
+ return rewriteValue_OpAMD64CMOVQCS(v)
case ssaop.OpAMD64CMOVQEQ:
- return rewriteValueAMD64_OpAMD64CMOVQEQ(v)
+ return rewriteValue_OpAMD64CMOVQEQ(v)
case ssaop.OpAMD64CMOVQGE:
- return rewriteValueAMD64_OpAMD64CMOVQGE(v)
+ return rewriteValue_OpAMD64CMOVQGE(v)
case ssaop.OpAMD64CMOVQGT:
- return rewriteValueAMD64_OpAMD64CMOVQGT(v)
+ return rewriteValue_OpAMD64CMOVQGT(v)
case ssaop.OpAMD64CMOVQHI:
- return rewriteValueAMD64_OpAMD64CMOVQHI(v)
+ return rewriteValue_OpAMD64CMOVQHI(v)
case ssaop.OpAMD64CMOVQLE:
- return rewriteValueAMD64_OpAMD64CMOVQLE(v)
+ return rewriteValue_OpAMD64CMOVQLE(v)
case ssaop.OpAMD64CMOVQLS:
- return rewriteValueAMD64_OpAMD64CMOVQLS(v)
+ return rewriteValue_OpAMD64CMOVQLS(v)
case ssaop.OpAMD64CMOVQLT:
- return rewriteValueAMD64_OpAMD64CMOVQLT(v)
+ return rewriteValue_OpAMD64CMOVQLT(v)
case ssaop.OpAMD64CMOVQNE:
- return rewriteValueAMD64_OpAMD64CMOVQNE(v)
+ return rewriteValue_OpAMD64CMOVQNE(v)
case ssaop.OpAMD64CMOVWCC:
- return rewriteValueAMD64_OpAMD64CMOVWCC(v)
+ return rewriteValue_OpAMD64CMOVWCC(v)
case ssaop.OpAMD64CMOVWCS:
- return rewriteValueAMD64_OpAMD64CMOVWCS(v)
+ return rewriteValue_OpAMD64CMOVWCS(v)
case ssaop.OpAMD64CMOVWEQ:
- return rewriteValueAMD64_OpAMD64CMOVWEQ(v)
+ return rewriteValue_OpAMD64CMOVWEQ(v)
case ssaop.OpAMD64CMOVWGE:
- return rewriteValueAMD64_OpAMD64CMOVWGE(v)
+ return rewriteValue_OpAMD64CMOVWGE(v)
case ssaop.OpAMD64CMOVWGT:
- return rewriteValueAMD64_OpAMD64CMOVWGT(v)
+ return rewriteValue_OpAMD64CMOVWGT(v)
case ssaop.OpAMD64CMOVWHI:
- return rewriteValueAMD64_OpAMD64CMOVWHI(v)
+ return rewriteValue_OpAMD64CMOVWHI(v)
case ssaop.OpAMD64CMOVWLE:
- return rewriteValueAMD64_OpAMD64CMOVWLE(v)
+ return rewriteValue_OpAMD64CMOVWLE(v)
case ssaop.OpAMD64CMOVWLS:
- return rewriteValueAMD64_OpAMD64CMOVWLS(v)
+ return rewriteValue_OpAMD64CMOVWLS(v)
case ssaop.OpAMD64CMOVWLT:
- return rewriteValueAMD64_OpAMD64CMOVWLT(v)
+ return rewriteValue_OpAMD64CMOVWLT(v)
case ssaop.OpAMD64CMOVWNE:
- return rewriteValueAMD64_OpAMD64CMOVWNE(v)
+ return rewriteValue_OpAMD64CMOVWNE(v)
case ssaop.OpAMD64CMPB:
- return rewriteValueAMD64_OpAMD64CMPB(v)
+ return rewriteValue_OpAMD64CMPB(v)
case ssaop.OpAMD64CMPBconst:
- return rewriteValueAMD64_OpAMD64CMPBconst(v)
+ return rewriteValue_OpAMD64CMPBconst(v)
case ssaop.OpAMD64CMPBconstload:
- return rewriteValueAMD64_OpAMD64CMPBconstload(v)
+ return rewriteValue_OpAMD64CMPBconstload(v)
case ssaop.OpAMD64CMPBload:
- return rewriteValueAMD64_OpAMD64CMPBload(v)
+ return rewriteValue_OpAMD64CMPBload(v)
case ssaop.OpAMD64CMPL:
- return rewriteValueAMD64_OpAMD64CMPL(v)
+ return rewriteValue_OpAMD64CMPL(v)
case ssaop.OpAMD64CMPLconst:
- return rewriteValueAMD64_OpAMD64CMPLconst(v)
+ return rewriteValue_OpAMD64CMPLconst(v)
case ssaop.OpAMD64CMPLconstload:
- return rewriteValueAMD64_OpAMD64CMPLconstload(v)
+ return rewriteValue_OpAMD64CMPLconstload(v)
case ssaop.OpAMD64CMPLload:
- return rewriteValueAMD64_OpAMD64CMPLload(v)
+ return rewriteValue_OpAMD64CMPLload(v)
case ssaop.OpAMD64CMPQ:
- return rewriteValueAMD64_OpAMD64CMPQ(v)
+ return rewriteValue_OpAMD64CMPQ(v)
case ssaop.OpAMD64CMPQconst:
- return rewriteValueAMD64_OpAMD64CMPQconst(v)
+ return rewriteValue_OpAMD64CMPQconst(v)
case ssaop.OpAMD64CMPQconstload:
- return rewriteValueAMD64_OpAMD64CMPQconstload(v)
+ return rewriteValue_OpAMD64CMPQconstload(v)
case ssaop.OpAMD64CMPQload:
- return rewriteValueAMD64_OpAMD64CMPQload(v)
+ return rewriteValue_OpAMD64CMPQload(v)
case ssaop.OpAMD64CMPW:
- return rewriteValueAMD64_OpAMD64CMPW(v)
+ return rewriteValue_OpAMD64CMPW(v)
case ssaop.OpAMD64CMPWconst:
- return rewriteValueAMD64_OpAMD64CMPWconst(v)
+ return rewriteValue_OpAMD64CMPWconst(v)
case ssaop.OpAMD64CMPWconstload:
- return rewriteValueAMD64_OpAMD64CMPWconstload(v)
+ return rewriteValue_OpAMD64CMPWconstload(v)
case ssaop.OpAMD64CMPWload:
- return rewriteValueAMD64_OpAMD64CMPWload(v)
+ return rewriteValue_OpAMD64CMPWload(v)
case ssaop.OpAMD64CMPXCHGLlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v)
+ return rewriteValue_OpAMD64CMPXCHGLlock(v)
case ssaop.OpAMD64CMPXCHGQlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v)
+ return rewriteValue_OpAMD64CMPXCHGQlock(v)
case ssaop.OpAMD64CVTSD2SS:
- return rewriteValueAMD64_OpAMD64CVTSD2SS(v)
+ return rewriteValue_OpAMD64CVTSD2SS(v)
case ssaop.OpAMD64DIVSD:
- return rewriteValueAMD64_OpAMD64DIVSD(v)
+ return rewriteValue_OpAMD64DIVSD(v)
case ssaop.OpAMD64DIVSDload:
- return rewriteValueAMD64_OpAMD64DIVSDload(v)
+ return rewriteValue_OpAMD64DIVSDload(v)
case ssaop.OpAMD64DIVSS:
- return rewriteValueAMD64_OpAMD64DIVSS(v)
+ return rewriteValue_OpAMD64DIVSS(v)
case ssaop.OpAMD64DIVSSload:
- return rewriteValueAMD64_OpAMD64DIVSSload(v)
+ return rewriteValue_OpAMD64DIVSSload(v)
case ssaop.OpAMD64HMULL:
- return rewriteValueAMD64_OpAMD64HMULL(v)
+ return rewriteValue_OpAMD64HMULL(v)
case ssaop.OpAMD64HMULLU:
- return rewriteValueAMD64_OpAMD64HMULLU(v)
+ return rewriteValue_OpAMD64HMULLU(v)
case ssaop.OpAMD64HMULQ:
- return rewriteValueAMD64_OpAMD64HMULQ(v)
+ return rewriteValue_OpAMD64HMULQ(v)
case ssaop.OpAMD64HMULQU:
- return rewriteValueAMD64_OpAMD64HMULQU(v)
+ return rewriteValue_OpAMD64HMULQU(v)
case ssaop.OpAMD64KANDB:
- return rewriteValueAMD64_OpAMD64KANDB(v)
+ return rewriteValue_OpAMD64KANDB(v)
case ssaop.OpAMD64KANDW:
- return rewriteValueAMD64_OpAMD64KANDW(v)
+ return rewriteValue_OpAMD64KANDW(v)
case ssaop.OpAMD64KMOVBk:
- return rewriteValueAMD64_OpAMD64KMOVBk(v)
+ return rewriteValue_OpAMD64KMOVBk(v)
case ssaop.OpAMD64KMOVDk:
- return rewriteValueAMD64_OpAMD64KMOVDk(v)
+ return rewriteValue_OpAMD64KMOVDk(v)
case ssaop.OpAMD64KMOVQk:
- return rewriteValueAMD64_OpAMD64KMOVQk(v)
+ return rewriteValue_OpAMD64KMOVQk(v)
case ssaop.OpAMD64KMOVWk:
- return rewriteValueAMD64_OpAMD64KMOVWk(v)
+ return rewriteValue_OpAMD64KMOVWk(v)
case ssaop.OpAMD64LEAL:
- return rewriteValueAMD64_OpAMD64LEAL(v)
+ return rewriteValue_OpAMD64LEAL(v)
case ssaop.OpAMD64LEAL1:
- return rewriteValueAMD64_OpAMD64LEAL1(v)
+ return rewriteValue_OpAMD64LEAL1(v)
case ssaop.OpAMD64LEAL2:
- return rewriteValueAMD64_OpAMD64LEAL2(v)
+ return rewriteValue_OpAMD64LEAL2(v)
case ssaop.OpAMD64LEAL4:
- return rewriteValueAMD64_OpAMD64LEAL4(v)
+ return rewriteValue_OpAMD64LEAL4(v)
case ssaop.OpAMD64LEAL8:
- return rewriteValueAMD64_OpAMD64LEAL8(v)
+ return rewriteValue_OpAMD64LEAL8(v)
case ssaop.OpAMD64LEAQ:
- return rewriteValueAMD64_OpAMD64LEAQ(v)
+ return rewriteValue_OpAMD64LEAQ(v)
case ssaop.OpAMD64LEAQ1:
- return rewriteValueAMD64_OpAMD64LEAQ1(v)
+ return rewriteValue_OpAMD64LEAQ1(v)
case ssaop.OpAMD64LEAQ2:
- return rewriteValueAMD64_OpAMD64LEAQ2(v)
+ return rewriteValue_OpAMD64LEAQ2(v)
case ssaop.OpAMD64LEAQ4:
- return rewriteValueAMD64_OpAMD64LEAQ4(v)
+ return rewriteValue_OpAMD64LEAQ4(v)
case ssaop.OpAMD64LEAQ8:
- return rewriteValueAMD64_OpAMD64LEAQ8(v)
+ return rewriteValue_OpAMD64LEAQ8(v)
case ssaop.OpAMD64LoweredPanicBoundsCR:
- return rewriteValueAMD64_OpAMD64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpAMD64LoweredPanicBoundsCR(v)
case ssaop.OpAMD64LoweredPanicBoundsRC:
- return rewriteValueAMD64_OpAMD64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpAMD64LoweredPanicBoundsRC(v)
case ssaop.OpAMD64LoweredPanicBoundsRR:
- return rewriteValueAMD64_OpAMD64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpAMD64LoweredPanicBoundsRR(v)
case ssaop.OpAMD64MOVBELstore:
- return rewriteValueAMD64_OpAMD64MOVBELstore(v)
+ return rewriteValue_OpAMD64MOVBELstore(v)
case ssaop.OpAMD64MOVBEQstore:
- return rewriteValueAMD64_OpAMD64MOVBEQstore(v)
+ return rewriteValue_OpAMD64MOVBEQstore(v)
case ssaop.OpAMD64MOVBEWstore:
- return rewriteValueAMD64_OpAMD64MOVBEWstore(v)
+ return rewriteValue_OpAMD64MOVBEWstore(v)
case ssaop.OpAMD64MOVBQSX:
- return rewriteValueAMD64_OpAMD64MOVBQSX(v)
+ return rewriteValue_OpAMD64MOVBQSX(v)
case ssaop.OpAMD64MOVBQSXload:
- return rewriteValueAMD64_OpAMD64MOVBQSXload(v)
+ return rewriteValue_OpAMD64MOVBQSXload(v)
case ssaop.OpAMD64MOVBQZX:
- return rewriteValueAMD64_OpAMD64MOVBQZX(v)
+ return rewriteValue_OpAMD64MOVBQZX(v)
case ssaop.OpAMD64MOVBatomicload:
- return rewriteValueAMD64_OpAMD64MOVBatomicload(v)
+ return rewriteValue_OpAMD64MOVBatomicload(v)
case ssaop.OpAMD64MOVBload:
- return rewriteValueAMD64_OpAMD64MOVBload(v)
+ return rewriteValue_OpAMD64MOVBload(v)
case ssaop.OpAMD64MOVBstore:
- return rewriteValueAMD64_OpAMD64MOVBstore(v)
+ return rewriteValue_OpAMD64MOVBstore(v)
case ssaop.OpAMD64MOVBstoreconst:
- return rewriteValueAMD64_OpAMD64MOVBstoreconst(v)
+ return rewriteValue_OpAMD64MOVBstoreconst(v)
case ssaop.OpAMD64MOVLQSX:
- return rewriteValueAMD64_OpAMD64MOVLQSX(v)
+ return rewriteValue_OpAMD64MOVLQSX(v)
case ssaop.OpAMD64MOVLQSXload:
- return rewriteValueAMD64_OpAMD64MOVLQSXload(v)
+ return rewriteValue_OpAMD64MOVLQSXload(v)
case ssaop.OpAMD64MOVLQZX:
- return rewriteValueAMD64_OpAMD64MOVLQZX(v)
+ return rewriteValue_OpAMD64MOVLQZX(v)
case ssaop.OpAMD64MOVLatomicload:
- return rewriteValueAMD64_OpAMD64MOVLatomicload(v)
+ return rewriteValue_OpAMD64MOVLatomicload(v)
case ssaop.OpAMD64MOVLf2i:
- return rewriteValueAMD64_OpAMD64MOVLf2i(v)
+ return rewriteValue_OpAMD64MOVLf2i(v)
case ssaop.OpAMD64MOVLi2f:
- return rewriteValueAMD64_OpAMD64MOVLi2f(v)
+ return rewriteValue_OpAMD64MOVLi2f(v)
case ssaop.OpAMD64MOVLload:
- return rewriteValueAMD64_OpAMD64MOVLload(v)
+ return rewriteValue_OpAMD64MOVLload(v)
case ssaop.OpAMD64MOVLstore:
- return rewriteValueAMD64_OpAMD64MOVLstore(v)
+ return rewriteValue_OpAMD64MOVLstore(v)
case ssaop.OpAMD64MOVLstoreconst:
- return rewriteValueAMD64_OpAMD64MOVLstoreconst(v)
+ return rewriteValue_OpAMD64MOVLstoreconst(v)
case ssaop.OpAMD64MOVOload:
- return rewriteValueAMD64_OpAMD64MOVOload(v)
+ return rewriteValue_OpAMD64MOVOload(v)
case ssaop.OpAMD64MOVOstore:
- return rewriteValueAMD64_OpAMD64MOVOstore(v)
+ return rewriteValue_OpAMD64MOVOstore(v)
case ssaop.OpAMD64MOVOstoreconst:
- return rewriteValueAMD64_OpAMD64MOVOstoreconst(v)
+ return rewriteValue_OpAMD64MOVOstoreconst(v)
case ssaop.OpAMD64MOVQatomicload:
- return rewriteValueAMD64_OpAMD64MOVQatomicload(v)
+ return rewriteValue_OpAMD64MOVQatomicload(v)
case ssaop.OpAMD64MOVQf2i:
- return rewriteValueAMD64_OpAMD64MOVQf2i(v)
+ return rewriteValue_OpAMD64MOVQf2i(v)
case ssaop.OpAMD64MOVQi2f:
- return rewriteValueAMD64_OpAMD64MOVQi2f(v)
+ return rewriteValue_OpAMD64MOVQi2f(v)
case ssaop.OpAMD64MOVQload:
- return rewriteValueAMD64_OpAMD64MOVQload(v)
+ return rewriteValue_OpAMD64MOVQload(v)
case ssaop.OpAMD64MOVQstore:
- return rewriteValueAMD64_OpAMD64MOVQstore(v)
+ return rewriteValue_OpAMD64MOVQstore(v)
case ssaop.OpAMD64MOVQstoreconst:
- return rewriteValueAMD64_OpAMD64MOVQstoreconst(v)
+ return rewriteValue_OpAMD64MOVQstoreconst(v)
case ssaop.OpAMD64MOVSDload:
- return rewriteValueAMD64_OpAMD64MOVSDload(v)
+ return rewriteValue_OpAMD64MOVSDload(v)
case ssaop.OpAMD64MOVSDstore:
- return rewriteValueAMD64_OpAMD64MOVSDstore(v)
+ return rewriteValue_OpAMD64MOVSDstore(v)
case ssaop.OpAMD64MOVSSload:
- return rewriteValueAMD64_OpAMD64MOVSSload(v)
+ return rewriteValue_OpAMD64MOVSSload(v)
case ssaop.OpAMD64MOVSSstore:
- return rewriteValueAMD64_OpAMD64MOVSSstore(v)
+ return rewriteValue_OpAMD64MOVSSstore(v)
case ssaop.OpAMD64MOVWQSX:
- return rewriteValueAMD64_OpAMD64MOVWQSX(v)
+ return rewriteValue_OpAMD64MOVWQSX(v)
case ssaop.OpAMD64MOVWQSXload:
- return rewriteValueAMD64_OpAMD64MOVWQSXload(v)
+ return rewriteValue_OpAMD64MOVWQSXload(v)
case ssaop.OpAMD64MOVWQZX:
- return rewriteValueAMD64_OpAMD64MOVWQZX(v)
+ return rewriteValue_OpAMD64MOVWQZX(v)
case ssaop.OpAMD64MOVWload:
- return rewriteValueAMD64_OpAMD64MOVWload(v)
+ return rewriteValue_OpAMD64MOVWload(v)
case ssaop.OpAMD64MOVWstore:
- return rewriteValueAMD64_OpAMD64MOVWstore(v)
+ return rewriteValue_OpAMD64MOVWstore(v)
case ssaop.OpAMD64MOVWstoreconst:
- return rewriteValueAMD64_OpAMD64MOVWstoreconst(v)
+ return rewriteValue_OpAMD64MOVWstoreconst(v)
case ssaop.OpAMD64MULL:
- return rewriteValueAMD64_OpAMD64MULL(v)
+ return rewriteValue_OpAMD64MULL(v)
case ssaop.OpAMD64MULLconst:
- return rewriteValueAMD64_OpAMD64MULLconst(v)
+ return rewriteValue_OpAMD64MULLconst(v)
case ssaop.OpAMD64MULQ:
- return rewriteValueAMD64_OpAMD64MULQ(v)
+ return rewriteValue_OpAMD64MULQ(v)
case ssaop.OpAMD64MULQconst:
- return rewriteValueAMD64_OpAMD64MULQconst(v)
+ return rewriteValue_OpAMD64MULQconst(v)
case ssaop.OpAMD64MULSD:
- return rewriteValueAMD64_OpAMD64MULSD(v)
+ return rewriteValue_OpAMD64MULSD(v)
case ssaop.OpAMD64MULSDload:
- return rewriteValueAMD64_OpAMD64MULSDload(v)
+ return rewriteValue_OpAMD64MULSDload(v)
case ssaop.OpAMD64MULSS:
- return rewriteValueAMD64_OpAMD64MULSS(v)
+ return rewriteValue_OpAMD64MULSS(v)
case ssaop.OpAMD64MULSSload:
- return rewriteValueAMD64_OpAMD64MULSSload(v)
+ return rewriteValue_OpAMD64MULSSload(v)
case ssaop.OpAMD64NEGL:
- return rewriteValueAMD64_OpAMD64NEGL(v)
+ return rewriteValue_OpAMD64NEGL(v)
case ssaop.OpAMD64NEGQ:
- return rewriteValueAMD64_OpAMD64NEGQ(v)
+ return rewriteValue_OpAMD64NEGQ(v)
case ssaop.OpAMD64NOTL:
- return rewriteValueAMD64_OpAMD64NOTL(v)
+ return rewriteValue_OpAMD64NOTL(v)
case ssaop.OpAMD64NOTQ:
- return rewriteValueAMD64_OpAMD64NOTQ(v)
+ return rewriteValue_OpAMD64NOTQ(v)
case ssaop.OpAMD64ORBconstmodify:
- return rewriteValueAMD64_OpAMD64ORBconstmodify(v)
+ return rewriteValue_OpAMD64ORBconstmodify(v)
case ssaop.OpAMD64ORL:
- return rewriteValueAMD64_OpAMD64ORL(v)
+ return rewriteValue_OpAMD64ORL(v)
case ssaop.OpAMD64ORLconst:
- return rewriteValueAMD64_OpAMD64ORLconst(v)
+ return rewriteValue_OpAMD64ORLconst(v)
case ssaop.OpAMD64ORLconstmodify:
- return rewriteValueAMD64_OpAMD64ORLconstmodify(v)
+ return rewriteValue_OpAMD64ORLconstmodify(v)
case ssaop.OpAMD64ORLload:
- return rewriteValueAMD64_OpAMD64ORLload(v)
+ return rewriteValue_OpAMD64ORLload(v)
case ssaop.OpAMD64ORLmodify:
- return rewriteValueAMD64_OpAMD64ORLmodify(v)
+ return rewriteValue_OpAMD64ORLmodify(v)
case ssaop.OpAMD64ORQ:
- return rewriteValueAMD64_OpAMD64ORQ(v)
+ return rewriteValue_OpAMD64ORQ(v)
case ssaop.OpAMD64ORQconst:
- return rewriteValueAMD64_OpAMD64ORQconst(v)
+ return rewriteValue_OpAMD64ORQconst(v)
case ssaop.OpAMD64ORQconstmodify:
- return rewriteValueAMD64_OpAMD64ORQconstmodify(v)
+ return rewriteValue_OpAMD64ORQconstmodify(v)
case ssaop.OpAMD64ORQload:
- return rewriteValueAMD64_OpAMD64ORQload(v)
+ return rewriteValue_OpAMD64ORQload(v)
case ssaop.OpAMD64ORQmodify:
- return rewriteValueAMD64_OpAMD64ORQmodify(v)
+ return rewriteValue_OpAMD64ORQmodify(v)
case ssaop.OpAMD64ORWconstmodify:
- return rewriteValueAMD64_OpAMD64ORWconstmodify(v)
+ return rewriteValue_OpAMD64ORWconstmodify(v)
case ssaop.OpAMD64ROLB:
- return rewriteValueAMD64_OpAMD64ROLB(v)
+ return rewriteValue_OpAMD64ROLB(v)
case ssaop.OpAMD64ROLBconst:
- return rewriteValueAMD64_OpAMD64ROLBconst(v)
+ return rewriteValue_OpAMD64ROLBconst(v)
case ssaop.OpAMD64ROLL:
- return rewriteValueAMD64_OpAMD64ROLL(v)
+ return rewriteValue_OpAMD64ROLL(v)
case ssaop.OpAMD64ROLLconst:
- return rewriteValueAMD64_OpAMD64ROLLconst(v)
+ return rewriteValue_OpAMD64ROLLconst(v)
case ssaop.OpAMD64ROLQ:
- return rewriteValueAMD64_OpAMD64ROLQ(v)
+ return rewriteValue_OpAMD64ROLQ(v)
case ssaop.OpAMD64ROLQconst:
- return rewriteValueAMD64_OpAMD64ROLQconst(v)
+ return rewriteValue_OpAMD64ROLQconst(v)
case ssaop.OpAMD64ROLW:
- return rewriteValueAMD64_OpAMD64ROLW(v)
+ return rewriteValue_OpAMD64ROLW(v)
case ssaop.OpAMD64ROLWconst:
- return rewriteValueAMD64_OpAMD64ROLWconst(v)
+ return rewriteValue_OpAMD64ROLWconst(v)
case ssaop.OpAMD64RORB:
- return rewriteValueAMD64_OpAMD64RORB(v)
+ return rewriteValue_OpAMD64RORB(v)
case ssaop.OpAMD64RORL:
- return rewriteValueAMD64_OpAMD64RORL(v)
+ return rewriteValue_OpAMD64RORL(v)
case ssaop.OpAMD64RORQ:
- return rewriteValueAMD64_OpAMD64RORQ(v)
+ return rewriteValue_OpAMD64RORQ(v)
case ssaop.OpAMD64RORW:
- return rewriteValueAMD64_OpAMD64RORW(v)
+ return rewriteValue_OpAMD64RORW(v)
case ssaop.OpAMD64SARB:
- return rewriteValueAMD64_OpAMD64SARB(v)
+ return rewriteValue_OpAMD64SARB(v)
case ssaop.OpAMD64SARBconst:
- return rewriteValueAMD64_OpAMD64SARBconst(v)
+ return rewriteValue_OpAMD64SARBconst(v)
case ssaop.OpAMD64SARL:
- return rewriteValueAMD64_OpAMD64SARL(v)
+ return rewriteValue_OpAMD64SARL(v)
case ssaop.OpAMD64SARLconst:
- return rewriteValueAMD64_OpAMD64SARLconst(v)
+ return rewriteValue_OpAMD64SARLconst(v)
case ssaop.OpAMD64SARQ:
- return rewriteValueAMD64_OpAMD64SARQ(v)
+ return rewriteValue_OpAMD64SARQ(v)
case ssaop.OpAMD64SARQconst:
- return rewriteValueAMD64_OpAMD64SARQconst(v)
+ return rewriteValue_OpAMD64SARQconst(v)
case ssaop.OpAMD64SARW:
- return rewriteValueAMD64_OpAMD64SARW(v)
+ return rewriteValue_OpAMD64SARW(v)
case ssaop.OpAMD64SARWconst:
- return rewriteValueAMD64_OpAMD64SARWconst(v)
+ return rewriteValue_OpAMD64SARWconst(v)
case ssaop.OpAMD64SARXLload:
- return rewriteValueAMD64_OpAMD64SARXLload(v)
+ return rewriteValue_OpAMD64SARXLload(v)
case ssaop.OpAMD64SARXQload:
- return rewriteValueAMD64_OpAMD64SARXQload(v)
+ return rewriteValue_OpAMD64SARXQload(v)
case ssaop.OpAMD64SBBLcarrymask:
- return rewriteValueAMD64_OpAMD64SBBLcarrymask(v)
+ return rewriteValue_OpAMD64SBBLcarrymask(v)
case ssaop.OpAMD64SBBQ:
- return rewriteValueAMD64_OpAMD64SBBQ(v)
+ return rewriteValue_OpAMD64SBBQ(v)
case ssaop.OpAMD64SBBQcarrymask:
- return rewriteValueAMD64_OpAMD64SBBQcarrymask(v)
+ return rewriteValue_OpAMD64SBBQcarrymask(v)
case ssaop.OpAMD64SBBQconst:
- return rewriteValueAMD64_OpAMD64SBBQconst(v)
+ return rewriteValue_OpAMD64SBBQconst(v)
case ssaop.OpAMD64SETA:
- return rewriteValueAMD64_OpAMD64SETA(v)
+ return rewriteValue_OpAMD64SETA(v)
case ssaop.OpAMD64SETAE:
- return rewriteValueAMD64_OpAMD64SETAE(v)
+ return rewriteValue_OpAMD64SETAE(v)
case ssaop.OpAMD64SETAEstore:
- return rewriteValueAMD64_OpAMD64SETAEstore(v)
+ return rewriteValue_OpAMD64SETAEstore(v)
case ssaop.OpAMD64SETAstore:
- return rewriteValueAMD64_OpAMD64SETAstore(v)
+ return rewriteValue_OpAMD64SETAstore(v)
case ssaop.OpAMD64SETB:
- return rewriteValueAMD64_OpAMD64SETB(v)
+ return rewriteValue_OpAMD64SETB(v)
case ssaop.OpAMD64SETBE:
- return rewriteValueAMD64_OpAMD64SETBE(v)
+ return rewriteValue_OpAMD64SETBE(v)
case ssaop.OpAMD64SETBEstore:
- return rewriteValueAMD64_OpAMD64SETBEstore(v)
+ return rewriteValue_OpAMD64SETBEstore(v)
case ssaop.OpAMD64SETBstore:
- return rewriteValueAMD64_OpAMD64SETBstore(v)
+ return rewriteValue_OpAMD64SETBstore(v)
case ssaop.OpAMD64SETEQ:
- return rewriteValueAMD64_OpAMD64SETEQ(v)
+ return rewriteValue_OpAMD64SETEQ(v)
case ssaop.OpAMD64SETEQstore:
- return rewriteValueAMD64_OpAMD64SETEQstore(v)
+ return rewriteValue_OpAMD64SETEQstore(v)
case ssaop.OpAMD64SETG:
- return rewriteValueAMD64_OpAMD64SETG(v)
+ return rewriteValue_OpAMD64SETG(v)
case ssaop.OpAMD64SETGE:
- return rewriteValueAMD64_OpAMD64SETGE(v)
+ return rewriteValue_OpAMD64SETGE(v)
case ssaop.OpAMD64SETGEstore:
- return rewriteValueAMD64_OpAMD64SETGEstore(v)
+ return rewriteValue_OpAMD64SETGEstore(v)
case ssaop.OpAMD64SETGstore:
- return rewriteValueAMD64_OpAMD64SETGstore(v)
+ return rewriteValue_OpAMD64SETGstore(v)
case ssaop.OpAMD64SETL:
- return rewriteValueAMD64_OpAMD64SETL(v)
+ return rewriteValue_OpAMD64SETL(v)
case ssaop.OpAMD64SETLE:
- return rewriteValueAMD64_OpAMD64SETLE(v)
+ return rewriteValue_OpAMD64SETLE(v)
case ssaop.OpAMD64SETLEstore:
- return rewriteValueAMD64_OpAMD64SETLEstore(v)
+ return rewriteValue_OpAMD64SETLEstore(v)
case ssaop.OpAMD64SETLstore:
- return rewriteValueAMD64_OpAMD64SETLstore(v)
+ return rewriteValue_OpAMD64SETLstore(v)
case ssaop.OpAMD64SETNE:
- return rewriteValueAMD64_OpAMD64SETNE(v)
+ return rewriteValue_OpAMD64SETNE(v)
case ssaop.OpAMD64SETNEstore:
- return rewriteValueAMD64_OpAMD64SETNEstore(v)
+ return rewriteValue_OpAMD64SETNEstore(v)
case ssaop.OpAMD64SHLL:
- return rewriteValueAMD64_OpAMD64SHLL(v)
+ return rewriteValue_OpAMD64SHLL(v)
case ssaop.OpAMD64SHLLconst:
- return rewriteValueAMD64_OpAMD64SHLLconst(v)
+ return rewriteValue_OpAMD64SHLLconst(v)
case ssaop.OpAMD64SHLQ:
- return rewriteValueAMD64_OpAMD64SHLQ(v)
+ return rewriteValue_OpAMD64SHLQ(v)
case ssaop.OpAMD64SHLQconst:
- return rewriteValueAMD64_OpAMD64SHLQconst(v)
+ return rewriteValue_OpAMD64SHLQconst(v)
case ssaop.OpAMD64SHLXLload:
- return rewriteValueAMD64_OpAMD64SHLXLload(v)
+ return rewriteValue_OpAMD64SHLXLload(v)
case ssaop.OpAMD64SHLXQload:
- return rewriteValueAMD64_OpAMD64SHLXQload(v)
+ return rewriteValue_OpAMD64SHLXQload(v)
case ssaop.OpAMD64SHRB:
- return rewriteValueAMD64_OpAMD64SHRB(v)
+ return rewriteValue_OpAMD64SHRB(v)
case ssaop.OpAMD64SHRBconst:
- return rewriteValueAMD64_OpAMD64SHRBconst(v)
+ return rewriteValue_OpAMD64SHRBconst(v)
case ssaop.OpAMD64SHRL:
- return rewriteValueAMD64_OpAMD64SHRL(v)
+ return rewriteValue_OpAMD64SHRL(v)
case ssaop.OpAMD64SHRLconst:
- return rewriteValueAMD64_OpAMD64SHRLconst(v)
+ return rewriteValue_OpAMD64SHRLconst(v)
case ssaop.OpAMD64SHRQ:
- return rewriteValueAMD64_OpAMD64SHRQ(v)
+ return rewriteValue_OpAMD64SHRQ(v)
case ssaop.OpAMD64SHRQconst:
- return rewriteValueAMD64_OpAMD64SHRQconst(v)
+ return rewriteValue_OpAMD64SHRQconst(v)
case ssaop.OpAMD64SHRW:
- return rewriteValueAMD64_OpAMD64SHRW(v)
+ return rewriteValue_OpAMD64SHRW(v)
case ssaop.OpAMD64SHRWconst:
- return rewriteValueAMD64_OpAMD64SHRWconst(v)
+ return rewriteValue_OpAMD64SHRWconst(v)
case ssaop.OpAMD64SHRXLload:
- return rewriteValueAMD64_OpAMD64SHRXLload(v)
+ return rewriteValue_OpAMD64SHRXLload(v)
case ssaop.OpAMD64SHRXQload:
- return rewriteValueAMD64_OpAMD64SHRXQload(v)
+ return rewriteValue_OpAMD64SHRXQload(v)
case ssaop.OpAMD64SUBL:
- return rewriteValueAMD64_OpAMD64SUBL(v)
+ return rewriteValue_OpAMD64SUBL(v)
case ssaop.OpAMD64SUBLconst:
- return rewriteValueAMD64_OpAMD64SUBLconst(v)
+ return rewriteValue_OpAMD64SUBLconst(v)
case ssaop.OpAMD64SUBLload:
- return rewriteValueAMD64_OpAMD64SUBLload(v)
+ return rewriteValue_OpAMD64SUBLload(v)
case ssaop.OpAMD64SUBLmodify:
- return rewriteValueAMD64_OpAMD64SUBLmodify(v)
+ return rewriteValue_OpAMD64SUBLmodify(v)
case ssaop.OpAMD64SUBQ:
- return rewriteValueAMD64_OpAMD64SUBQ(v)
+ return rewriteValue_OpAMD64SUBQ(v)
case ssaop.OpAMD64SUBQborrow:
- return rewriteValueAMD64_OpAMD64SUBQborrow(v)
+ return rewriteValue_OpAMD64SUBQborrow(v)
case ssaop.OpAMD64SUBQconst:
- return rewriteValueAMD64_OpAMD64SUBQconst(v)
+ return rewriteValue_OpAMD64SUBQconst(v)
case ssaop.OpAMD64SUBQload:
- return rewriteValueAMD64_OpAMD64SUBQload(v)
+ return rewriteValue_OpAMD64SUBQload(v)
case ssaop.OpAMD64SUBQmodify:
- return rewriteValueAMD64_OpAMD64SUBQmodify(v)
+ return rewriteValue_OpAMD64SUBQmodify(v)
case ssaop.OpAMD64SUBSD:
- return rewriteValueAMD64_OpAMD64SUBSD(v)
+ return rewriteValue_OpAMD64SUBSD(v)
case ssaop.OpAMD64SUBSDload:
- return rewriteValueAMD64_OpAMD64SUBSDload(v)
+ return rewriteValue_OpAMD64SUBSDload(v)
case ssaop.OpAMD64SUBSS:
- return rewriteValueAMD64_OpAMD64SUBSS(v)
+ return rewriteValue_OpAMD64SUBSS(v)
case ssaop.OpAMD64SUBSSload:
- return rewriteValueAMD64_OpAMD64SUBSSload(v)
+ return rewriteValue_OpAMD64SUBSSload(v)
case ssaop.OpAMD64TESTB:
- return rewriteValueAMD64_OpAMD64TESTB(v)
+ return rewriteValue_OpAMD64TESTB(v)
case ssaop.OpAMD64TESTBconst:
- return rewriteValueAMD64_OpAMD64TESTBconst(v)
+ return rewriteValue_OpAMD64TESTBconst(v)
case ssaop.OpAMD64TESTL:
- return rewriteValueAMD64_OpAMD64TESTL(v)
+ return rewriteValue_OpAMD64TESTL(v)
case ssaop.OpAMD64TESTLconst:
- return rewriteValueAMD64_OpAMD64TESTLconst(v)
+ return rewriteValue_OpAMD64TESTLconst(v)
case ssaop.OpAMD64TESTQ:
- return rewriteValueAMD64_OpAMD64TESTQ(v)
+ return rewriteValue_OpAMD64TESTQ(v)
case ssaop.OpAMD64TESTQconst:
- return rewriteValueAMD64_OpAMD64TESTQconst(v)
+ return rewriteValue_OpAMD64TESTQconst(v)
case ssaop.OpAMD64TESTW:
- return rewriteValueAMD64_OpAMD64TESTW(v)
+ return rewriteValue_OpAMD64TESTW(v)
case ssaop.OpAMD64TESTWconst:
- return rewriteValueAMD64_OpAMD64TESTWconst(v)
+ return rewriteValue_OpAMD64TESTWconst(v)
case ssaop.OpAMD64VADDPD128:
- return rewriteValueAMD64_OpAMD64VADDPD128(v)
+ return rewriteValue_OpAMD64VADDPD128(v)
case ssaop.OpAMD64VADDPD256:
- return rewriteValueAMD64_OpAMD64VADDPD256(v)
+ return rewriteValue_OpAMD64VADDPD256(v)
case ssaop.OpAMD64VADDPD512:
- return rewriteValueAMD64_OpAMD64VADDPD512(v)
+ return rewriteValue_OpAMD64VADDPD512(v)
case ssaop.OpAMD64VADDPDMasked128:
- return rewriteValueAMD64_OpAMD64VADDPDMasked128(v)
+ return rewriteValue_OpAMD64VADDPDMasked128(v)
case ssaop.OpAMD64VADDPDMasked256:
- return rewriteValueAMD64_OpAMD64VADDPDMasked256(v)
+ return rewriteValue_OpAMD64VADDPDMasked256(v)
case ssaop.OpAMD64VADDPDMasked512:
- return rewriteValueAMD64_OpAMD64VADDPDMasked512(v)
+ return rewriteValue_OpAMD64VADDPDMasked512(v)
case ssaop.OpAMD64VADDPS128:
- return rewriteValueAMD64_OpAMD64VADDPS128(v)
+ return rewriteValue_OpAMD64VADDPS128(v)
case ssaop.OpAMD64VADDPS256:
- return rewriteValueAMD64_OpAMD64VADDPS256(v)
+ return rewriteValue_OpAMD64VADDPS256(v)
case ssaop.OpAMD64VADDPS512:
- return rewriteValueAMD64_OpAMD64VADDPS512(v)
+ return rewriteValue_OpAMD64VADDPS512(v)
case ssaop.OpAMD64VADDPSMasked128:
- return rewriteValueAMD64_OpAMD64VADDPSMasked128(v)
+ return rewriteValue_OpAMD64VADDPSMasked128(v)
case ssaop.OpAMD64VADDPSMasked256:
- return rewriteValueAMD64_OpAMD64VADDPSMasked256(v)
+ return rewriteValue_OpAMD64VADDPSMasked256(v)
case ssaop.OpAMD64VADDPSMasked512:
- return rewriteValueAMD64_OpAMD64VADDPSMasked512(v)
+ return rewriteValue_OpAMD64VADDPSMasked512(v)
case ssaop.OpAMD64VADDSUBPD128:
- return rewriteValueAMD64_OpAMD64VADDSUBPD128(v)
+ return rewriteValue_OpAMD64VADDSUBPD128(v)
case ssaop.OpAMD64VADDSUBPD256:
- return rewriteValueAMD64_OpAMD64VADDSUBPD256(v)
+ return rewriteValue_OpAMD64VADDSUBPD256(v)
case ssaop.OpAMD64VADDSUBPS128:
- return rewriteValueAMD64_OpAMD64VADDSUBPS128(v)
+ return rewriteValue_OpAMD64VADDSUBPS128(v)
case ssaop.OpAMD64VADDSUBPS256:
- return rewriteValueAMD64_OpAMD64VADDSUBPS256(v)
+ return rewriteValue_OpAMD64VADDSUBPS256(v)
case ssaop.OpAMD64VAESDEC128:
- return rewriteValueAMD64_OpAMD64VAESDEC128(v)
+ return rewriteValue_OpAMD64VAESDEC128(v)
case ssaop.OpAMD64VAESDEC256:
- return rewriteValueAMD64_OpAMD64VAESDEC256(v)
+ return rewriteValue_OpAMD64VAESDEC256(v)
case ssaop.OpAMD64VAESDECLAST128:
- return rewriteValueAMD64_OpAMD64VAESDECLAST128(v)
+ return rewriteValue_OpAMD64VAESDECLAST128(v)
case ssaop.OpAMD64VAESDECLAST256:
- return rewriteValueAMD64_OpAMD64VAESDECLAST256(v)
+ return rewriteValue_OpAMD64VAESDECLAST256(v)
case ssaop.OpAMD64VAESENC128:
- return rewriteValueAMD64_OpAMD64VAESENC128(v)
+ return rewriteValue_OpAMD64VAESENC128(v)
case ssaop.OpAMD64VAESENC256:
- return rewriteValueAMD64_OpAMD64VAESENC256(v)
+ return rewriteValue_OpAMD64VAESENC256(v)
case ssaop.OpAMD64VAESENCLAST128:
- return rewriteValueAMD64_OpAMD64VAESENCLAST128(v)
+ return rewriteValue_OpAMD64VAESENCLAST128(v)
case ssaop.OpAMD64VAESENCLAST256:
- return rewriteValueAMD64_OpAMD64VAESENCLAST256(v)
+ return rewriteValue_OpAMD64VAESENCLAST256(v)
case ssaop.OpAMD64VAESIMC128:
- return rewriteValueAMD64_OpAMD64VAESIMC128(v)
+ return rewriteValue_OpAMD64VAESIMC128(v)
case ssaop.OpAMD64VAESKEYGENASSIST128:
- return rewriteValueAMD64_OpAMD64VAESKEYGENASSIST128(v)
+ return rewriteValue_OpAMD64VAESKEYGENASSIST128(v)
case ssaop.OpAMD64VBROADCASTSD256:
- return rewriteValueAMD64_OpAMD64VBROADCASTSD256(v)
+ return rewriteValue_OpAMD64VBROADCASTSD256(v)
case ssaop.OpAMD64VBROADCASTSD512:
- return rewriteValueAMD64_OpAMD64VBROADCASTSD512(v)
+ return rewriteValue_OpAMD64VBROADCASTSD512(v)
case ssaop.OpAMD64VBROADCASTSDMasked256:
- return rewriteValueAMD64_OpAMD64VBROADCASTSDMasked256(v)
+ return rewriteValue_OpAMD64VBROADCASTSDMasked256(v)
case ssaop.OpAMD64VBROADCASTSDMasked512:
- return rewriteValueAMD64_OpAMD64VBROADCASTSDMasked512(v)
+ return rewriteValue_OpAMD64VBROADCASTSDMasked512(v)
case ssaop.OpAMD64VBROADCASTSS128:
- return rewriteValueAMD64_OpAMD64VBROADCASTSS128(v)
+ return rewriteValue_OpAMD64VBROADCASTSS128(v)
case ssaop.OpAMD64VBROADCASTSS256:
- return rewriteValueAMD64_OpAMD64VBROADCASTSS256(v)
+ return rewriteValue_OpAMD64VBROADCASTSS256(v)
case ssaop.OpAMD64VBROADCASTSS512:
- return rewriteValueAMD64_OpAMD64VBROADCASTSS512(v)
+ return rewriteValue_OpAMD64VBROADCASTSS512(v)
case ssaop.OpAMD64VBROADCASTSSMasked128:
- return rewriteValueAMD64_OpAMD64VBROADCASTSSMasked128(v)
+ return rewriteValue_OpAMD64VBROADCASTSSMasked128(v)
case ssaop.OpAMD64VBROADCASTSSMasked256:
- return rewriteValueAMD64_OpAMD64VBROADCASTSSMasked256(v)
+ return rewriteValue_OpAMD64VBROADCASTSSMasked256(v)
case ssaop.OpAMD64VBROADCASTSSMasked512:
- return rewriteValueAMD64_OpAMD64VBROADCASTSSMasked512(v)
+ return rewriteValue_OpAMD64VBROADCASTSSMasked512(v)
case ssaop.OpAMD64VCMPPD128:
- return rewriteValueAMD64_OpAMD64VCMPPD128(v)
+ return rewriteValue_OpAMD64VCMPPD128(v)
case ssaop.OpAMD64VCMPPD256:
- return rewriteValueAMD64_OpAMD64VCMPPD256(v)
+ return rewriteValue_OpAMD64VCMPPD256(v)
case ssaop.OpAMD64VCMPPD512:
- return rewriteValueAMD64_OpAMD64VCMPPD512(v)
+ return rewriteValue_OpAMD64VCMPPD512(v)
case ssaop.OpAMD64VCMPPDMasked128:
- return rewriteValueAMD64_OpAMD64VCMPPDMasked128(v)
+ return rewriteValue_OpAMD64VCMPPDMasked128(v)
case ssaop.OpAMD64VCMPPDMasked256:
- return rewriteValueAMD64_OpAMD64VCMPPDMasked256(v)
+ return rewriteValue_OpAMD64VCMPPDMasked256(v)
case ssaop.OpAMD64VCMPPDMasked512:
- return rewriteValueAMD64_OpAMD64VCMPPDMasked512(v)
+ return rewriteValue_OpAMD64VCMPPDMasked512(v)
case ssaop.OpAMD64VCMPPS128:
- return rewriteValueAMD64_OpAMD64VCMPPS128(v)
+ return rewriteValue_OpAMD64VCMPPS128(v)
case ssaop.OpAMD64VCMPPS256:
- return rewriteValueAMD64_OpAMD64VCMPPS256(v)
+ return rewriteValue_OpAMD64VCMPPS256(v)
case ssaop.OpAMD64VCMPPS512:
- return rewriteValueAMD64_OpAMD64VCMPPS512(v)
+ return rewriteValue_OpAMD64VCMPPS512(v)
case ssaop.OpAMD64VCMPPSMasked128:
- return rewriteValueAMD64_OpAMD64VCMPPSMasked128(v)
+ return rewriteValue_OpAMD64VCMPPSMasked128(v)
case ssaop.OpAMD64VCMPPSMasked256:
- return rewriteValueAMD64_OpAMD64VCMPPSMasked256(v)
+ return rewriteValue_OpAMD64VCMPPSMasked256(v)
case ssaop.OpAMD64VCMPPSMasked512:
- return rewriteValueAMD64_OpAMD64VCMPPSMasked512(v)
+ return rewriteValue_OpAMD64VCMPPSMasked512(v)
case ssaop.OpAMD64VCVTDQ2PD256:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PD256(v)
+ return rewriteValue_OpAMD64VCVTDQ2PD256(v)
case ssaop.OpAMD64VCVTDQ2PD512:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PD512(v)
+ return rewriteValue_OpAMD64VCVTDQ2PD512(v)
case ssaop.OpAMD64VCVTDQ2PDMasked256:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PDMasked256(v)
+ return rewriteValue_OpAMD64VCVTDQ2PDMasked256(v)
case ssaop.OpAMD64VCVTDQ2PDMasked512:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PDMasked512(v)
+ return rewriteValue_OpAMD64VCVTDQ2PDMasked512(v)
case ssaop.OpAMD64VCVTDQ2PS128:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PS128(v)
+ return rewriteValue_OpAMD64VCVTDQ2PS128(v)
case ssaop.OpAMD64VCVTDQ2PS256:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PS256(v)
+ return rewriteValue_OpAMD64VCVTDQ2PS256(v)
case ssaop.OpAMD64VCVTDQ2PS512:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PS512(v)
+ return rewriteValue_OpAMD64VCVTDQ2PS512(v)
case ssaop.OpAMD64VCVTDQ2PSMasked128:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked128(v)
+ return rewriteValue_OpAMD64VCVTDQ2PSMasked128(v)
case ssaop.OpAMD64VCVTDQ2PSMasked256:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked256(v)
+ return rewriteValue_OpAMD64VCVTDQ2PSMasked256(v)
case ssaop.OpAMD64VCVTDQ2PSMasked512:
- return rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked512(v)
+ return rewriteValue_OpAMD64VCVTDQ2PSMasked512(v)
case ssaop.OpAMD64VCVTPD2PS256:
- return rewriteValueAMD64_OpAMD64VCVTPD2PS256(v)
+ return rewriteValue_OpAMD64VCVTPD2PS256(v)
case ssaop.OpAMD64VCVTPD2PSMasked256:
- return rewriteValueAMD64_OpAMD64VCVTPD2PSMasked256(v)
+ return rewriteValue_OpAMD64VCVTPD2PSMasked256(v)
case ssaop.OpAMD64VCVTPD2PSX128:
- return rewriteValueAMD64_OpAMD64VCVTPD2PSX128(v)
+ return rewriteValue_OpAMD64VCVTPD2PSX128(v)
case ssaop.OpAMD64VCVTPD2PSXMasked128:
- return rewriteValueAMD64_OpAMD64VCVTPD2PSXMasked128(v)
+ return rewriteValue_OpAMD64VCVTPD2PSXMasked128(v)
case ssaop.OpAMD64VCVTPD2PSY128:
- return rewriteValueAMD64_OpAMD64VCVTPD2PSY128(v)
+ return rewriteValue_OpAMD64VCVTPD2PSY128(v)
case ssaop.OpAMD64VCVTPD2PSYMasked128:
- return rewriteValueAMD64_OpAMD64VCVTPD2PSYMasked128(v)
+ return rewriteValue_OpAMD64VCVTPD2PSYMasked128(v)
case ssaop.OpAMD64VCVTPS2PD256:
- return rewriteValueAMD64_OpAMD64VCVTPS2PD256(v)
+ return rewriteValue_OpAMD64VCVTPS2PD256(v)
case ssaop.OpAMD64VCVTPS2PD512:
- return rewriteValueAMD64_OpAMD64VCVTPS2PD512(v)
+ return rewriteValue_OpAMD64VCVTPS2PD512(v)
case ssaop.OpAMD64VCVTPS2PDMasked256:
- return rewriteValueAMD64_OpAMD64VCVTPS2PDMasked256(v)
+ return rewriteValue_OpAMD64VCVTPS2PDMasked256(v)
case ssaop.OpAMD64VCVTPS2PDMasked512:
- return rewriteValueAMD64_OpAMD64VCVTPS2PDMasked512(v)
+ return rewriteValue_OpAMD64VCVTPS2PDMasked512(v)
case ssaop.OpAMD64VCVTQQ2PD128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PD128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PD128(v)
case ssaop.OpAMD64VCVTQQ2PD256:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PD256(v)
+ return rewriteValue_OpAMD64VCVTQQ2PD256(v)
case ssaop.OpAMD64VCVTQQ2PD512:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PD512(v)
+ return rewriteValue_OpAMD64VCVTQQ2PD512(v)
case ssaop.OpAMD64VCVTQQ2PDMasked128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PDMasked128(v)
case ssaop.OpAMD64VCVTQQ2PDMasked256:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked256(v)
+ return rewriteValue_OpAMD64VCVTQQ2PDMasked256(v)
case ssaop.OpAMD64VCVTQQ2PDMasked512:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked512(v)
+ return rewriteValue_OpAMD64VCVTQQ2PDMasked512(v)
case ssaop.OpAMD64VCVTQQ2PS256:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PS256(v)
+ return rewriteValue_OpAMD64VCVTQQ2PS256(v)
case ssaop.OpAMD64VCVTQQ2PSMasked256:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PSMasked256(v)
+ return rewriteValue_OpAMD64VCVTQQ2PSMasked256(v)
case ssaop.OpAMD64VCVTQQ2PSX128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PSX128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PSX128(v)
case ssaop.OpAMD64VCVTQQ2PSXMasked128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PSXMasked128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PSXMasked128(v)
case ssaop.OpAMD64VCVTQQ2PSY128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PSY128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PSY128(v)
case ssaop.OpAMD64VCVTQQ2PSYMasked128:
- return rewriteValueAMD64_OpAMD64VCVTQQ2PSYMasked128(v)
+ return rewriteValue_OpAMD64VCVTQQ2PSYMasked128(v)
case ssaop.OpAMD64VCVTTPD2DQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQ256(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQ256(v)
case ssaop.OpAMD64VCVTTPD2DQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQMasked256(v)
case ssaop.OpAMD64VCVTTPD2DQX128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQX128(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQX128(v)
case ssaop.OpAMD64VCVTTPD2DQXMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQXMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQXMasked128(v)
case ssaop.OpAMD64VCVTTPD2DQY128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQY128(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQY128(v)
case ssaop.OpAMD64VCVTTPD2DQYMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2DQYMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2DQYMasked128(v)
case ssaop.OpAMD64VCVTTPD2QQ128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQ128(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQ128(v)
case ssaop.OpAMD64VCVTTPD2QQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQ256(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQ256(v)
case ssaop.OpAMD64VCVTTPD2QQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQ512(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQ512(v)
case ssaop.OpAMD64VCVTTPD2QQMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQMasked128(v)
case ssaop.OpAMD64VCVTTPD2QQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQMasked256(v)
case ssaop.OpAMD64VCVTTPD2QQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPD2QQMasked512(v)
case ssaop.OpAMD64VCVTTPD2UDQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQ256(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQ256(v)
case ssaop.OpAMD64VCVTTPD2UDQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQMasked256(v)
case ssaop.OpAMD64VCVTTPD2UDQX128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQX128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQX128(v)
case ssaop.OpAMD64VCVTTPD2UDQXMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQXMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQXMasked128(v)
case ssaop.OpAMD64VCVTTPD2UDQY128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQY128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQY128(v)
case ssaop.OpAMD64VCVTTPD2UDQYMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UDQYMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UDQYMasked128(v)
case ssaop.OpAMD64VCVTTPD2UQQ128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQ128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQ128(v)
case ssaop.OpAMD64VCVTTPD2UQQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQ256(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQ256(v)
case ssaop.OpAMD64VCVTTPD2UQQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQ512(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQ512(v)
case ssaop.OpAMD64VCVTTPD2UQQMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQMasked128(v)
case ssaop.OpAMD64VCVTTPD2UQQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQMasked256(v)
case ssaop.OpAMD64VCVTTPD2UQQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPD2UQQMasked512(v)
case ssaop.OpAMD64VCVTTPS2DQ128:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQ128(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQ128(v)
case ssaop.OpAMD64VCVTTPS2DQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQ256(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQ256(v)
case ssaop.OpAMD64VCVTTPS2DQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQ512(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQ512(v)
case ssaop.OpAMD64VCVTTPS2DQMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQMasked128(v)
case ssaop.OpAMD64VCVTTPS2DQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQMasked256(v)
case ssaop.OpAMD64VCVTTPS2DQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPS2DQMasked512(v)
case ssaop.OpAMD64VCVTTPS2QQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2QQ256(v)
+ return rewriteValue_OpAMD64VCVTTPS2QQ256(v)
case ssaop.OpAMD64VCVTTPS2QQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2QQ512(v)
+ return rewriteValue_OpAMD64VCVTTPS2QQ512(v)
case ssaop.OpAMD64VCVTTPS2QQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2QQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPS2QQMasked256(v)
case ssaop.OpAMD64VCVTTPS2QQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2QQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPS2QQMasked512(v)
case ssaop.OpAMD64VCVTTPS2UDQ128:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQ128(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQ128(v)
case ssaop.OpAMD64VCVTTPS2UDQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQ256(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQ256(v)
case ssaop.OpAMD64VCVTTPS2UDQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQ512(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQ512(v)
case ssaop.OpAMD64VCVTTPS2UDQMasked128:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked128(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQMasked128(v)
case ssaop.OpAMD64VCVTTPS2UDQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQMasked256(v)
case ssaop.OpAMD64VCVTTPS2UDQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPS2UDQMasked512(v)
case ssaop.OpAMD64VCVTTPS2UQQ256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UQQ256(v)
+ return rewriteValue_OpAMD64VCVTTPS2UQQ256(v)
case ssaop.OpAMD64VCVTTPS2UQQ512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UQQ512(v)
+ return rewriteValue_OpAMD64VCVTTPS2UQQ512(v)
case ssaop.OpAMD64VCVTTPS2UQQMasked256:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UQQMasked256(v)
+ return rewriteValue_OpAMD64VCVTTPS2UQQMasked256(v)
case ssaop.OpAMD64VCVTTPS2UQQMasked512:
- return rewriteValueAMD64_OpAMD64VCVTTPS2UQQMasked512(v)
+ return rewriteValue_OpAMD64VCVTTPS2UQQMasked512(v)
case ssaop.OpAMD64VCVTUDQ2PD256:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PD256(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PD256(v)
case ssaop.OpAMD64VCVTUDQ2PD512:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PD512(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PD512(v)
case ssaop.OpAMD64VCVTUDQ2PDMasked256:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PDMasked256(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PDMasked256(v)
case ssaop.OpAMD64VCVTUDQ2PDMasked512:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PDMasked512(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PDMasked512(v)
case ssaop.OpAMD64VCVTUDQ2PS128:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PS128(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PS128(v)
case ssaop.OpAMD64VCVTUDQ2PS256:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PS256(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PS256(v)
case ssaop.OpAMD64VCVTUDQ2PS512:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PS512(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PS512(v)
case ssaop.OpAMD64VCVTUDQ2PSMasked128:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked128(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PSMasked128(v)
case ssaop.OpAMD64VCVTUDQ2PSMasked256:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked256(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PSMasked256(v)
case ssaop.OpAMD64VCVTUDQ2PSMasked512:
- return rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked512(v)
+ return rewriteValue_OpAMD64VCVTUDQ2PSMasked512(v)
case ssaop.OpAMD64VCVTUQQ2PD128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PD128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PD128(v)
case ssaop.OpAMD64VCVTUQQ2PD256:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PD256(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PD256(v)
case ssaop.OpAMD64VCVTUQQ2PD512:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PD512(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PD512(v)
case ssaop.OpAMD64VCVTUQQ2PDMasked128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PDMasked128(v)
case ssaop.OpAMD64VCVTUQQ2PDMasked256:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked256(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PDMasked256(v)
case ssaop.OpAMD64VCVTUQQ2PDMasked512:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked512(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PDMasked512(v)
case ssaop.OpAMD64VCVTUQQ2PS256:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PS256(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PS256(v)
case ssaop.OpAMD64VCVTUQQ2PSMasked256:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PSMasked256(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PSMasked256(v)
case ssaop.OpAMD64VCVTUQQ2PSX128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PSX128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PSX128(v)
case ssaop.OpAMD64VCVTUQQ2PSXMasked128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PSXMasked128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PSXMasked128(v)
case ssaop.OpAMD64VCVTUQQ2PSY128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PSY128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PSY128(v)
case ssaop.OpAMD64VCVTUQQ2PSYMasked128:
- return rewriteValueAMD64_OpAMD64VCVTUQQ2PSYMasked128(v)
+ return rewriteValue_OpAMD64VCVTUQQ2PSYMasked128(v)
case ssaop.OpAMD64VDIVPD128:
- return rewriteValueAMD64_OpAMD64VDIVPD128(v)
+ return rewriteValue_OpAMD64VDIVPD128(v)
case ssaop.OpAMD64VDIVPD256:
- return rewriteValueAMD64_OpAMD64VDIVPD256(v)
+ return rewriteValue_OpAMD64VDIVPD256(v)
case ssaop.OpAMD64VDIVPD512:
- return rewriteValueAMD64_OpAMD64VDIVPD512(v)
+ return rewriteValue_OpAMD64VDIVPD512(v)
case ssaop.OpAMD64VDIVPDMasked128:
- return rewriteValueAMD64_OpAMD64VDIVPDMasked128(v)
+ return rewriteValue_OpAMD64VDIVPDMasked128(v)
case ssaop.OpAMD64VDIVPDMasked256:
- return rewriteValueAMD64_OpAMD64VDIVPDMasked256(v)
+ return rewriteValue_OpAMD64VDIVPDMasked256(v)
case ssaop.OpAMD64VDIVPDMasked512:
- return rewriteValueAMD64_OpAMD64VDIVPDMasked512(v)
+ return rewriteValue_OpAMD64VDIVPDMasked512(v)
case ssaop.OpAMD64VDIVPS128:
- return rewriteValueAMD64_OpAMD64VDIVPS128(v)
+ return rewriteValue_OpAMD64VDIVPS128(v)
case ssaop.OpAMD64VDIVPS256:
- return rewriteValueAMD64_OpAMD64VDIVPS256(v)
+ return rewriteValue_OpAMD64VDIVPS256(v)
case ssaop.OpAMD64VDIVPS512:
- return rewriteValueAMD64_OpAMD64VDIVPS512(v)
+ return rewriteValue_OpAMD64VDIVPS512(v)
case ssaop.OpAMD64VDIVPSMasked128:
- return rewriteValueAMD64_OpAMD64VDIVPSMasked128(v)
+ return rewriteValue_OpAMD64VDIVPSMasked128(v)
case ssaop.OpAMD64VDIVPSMasked256:
- return rewriteValueAMD64_OpAMD64VDIVPSMasked256(v)
+ return rewriteValue_OpAMD64VDIVPSMasked256(v)
case ssaop.OpAMD64VDIVPSMasked512:
- return rewriteValueAMD64_OpAMD64VDIVPSMasked512(v)
+ return rewriteValue_OpAMD64VDIVPSMasked512(v)
case ssaop.OpAMD64VEXPANDPDMasked128:
- return rewriteValueAMD64_OpAMD64VEXPANDPDMasked128(v)
+ return rewriteValue_OpAMD64VEXPANDPDMasked128(v)
case ssaop.OpAMD64VEXPANDPDMasked256:
- return rewriteValueAMD64_OpAMD64VEXPANDPDMasked256(v)
+ return rewriteValue_OpAMD64VEXPANDPDMasked256(v)
case ssaop.OpAMD64VEXPANDPSMasked128:
- return rewriteValueAMD64_OpAMD64VEXPANDPSMasked128(v)
+ return rewriteValue_OpAMD64VEXPANDPSMasked128(v)
case ssaop.OpAMD64VEXPANDPSMasked256:
- return rewriteValueAMD64_OpAMD64VEXPANDPSMasked256(v)
+ return rewriteValue_OpAMD64VEXPANDPSMasked256(v)
case ssaop.OpAMD64VFMADD213PD128:
- return rewriteValueAMD64_OpAMD64VFMADD213PD128(v)
+ return rewriteValue_OpAMD64VFMADD213PD128(v)
case ssaop.OpAMD64VFMADD213PD256:
- return rewriteValueAMD64_OpAMD64VFMADD213PD256(v)
+ return rewriteValue_OpAMD64VFMADD213PD256(v)
case ssaop.OpAMD64VFMADD213PD512:
- return rewriteValueAMD64_OpAMD64VFMADD213PD512(v)
+ return rewriteValue_OpAMD64VFMADD213PD512(v)
case ssaop.OpAMD64VFMADD213PDMasked128:
- return rewriteValueAMD64_OpAMD64VFMADD213PDMasked128(v)
+ return rewriteValue_OpAMD64VFMADD213PDMasked128(v)
case ssaop.OpAMD64VFMADD213PDMasked256:
- return rewriteValueAMD64_OpAMD64VFMADD213PDMasked256(v)
+ return rewriteValue_OpAMD64VFMADD213PDMasked256(v)
case ssaop.OpAMD64VFMADD213PDMasked512:
- return rewriteValueAMD64_OpAMD64VFMADD213PDMasked512(v)
+ return rewriteValue_OpAMD64VFMADD213PDMasked512(v)
case ssaop.OpAMD64VFMADD213PS128:
- return rewriteValueAMD64_OpAMD64VFMADD213PS128(v)
+ return rewriteValue_OpAMD64VFMADD213PS128(v)
case ssaop.OpAMD64VFMADD213PS256:
- return rewriteValueAMD64_OpAMD64VFMADD213PS256(v)
+ return rewriteValue_OpAMD64VFMADD213PS256(v)
case ssaop.OpAMD64VFMADD213PS512:
- return rewriteValueAMD64_OpAMD64VFMADD213PS512(v)
+ return rewriteValue_OpAMD64VFMADD213PS512(v)
case ssaop.OpAMD64VFMADD213PSMasked128:
- return rewriteValueAMD64_OpAMD64VFMADD213PSMasked128(v)
+ return rewriteValue_OpAMD64VFMADD213PSMasked128(v)
case ssaop.OpAMD64VFMADD213PSMasked256:
- return rewriteValueAMD64_OpAMD64VFMADD213PSMasked256(v)
+ return rewriteValue_OpAMD64VFMADD213PSMasked256(v)
case ssaop.OpAMD64VFMADD213PSMasked512:
- return rewriteValueAMD64_OpAMD64VFMADD213PSMasked512(v)
+ return rewriteValue_OpAMD64VFMADD213PSMasked512(v)
case ssaop.OpAMD64VFMADDSUB213PD128:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PD128(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PD128(v)
case ssaop.OpAMD64VFMADDSUB213PD256:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PD256(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PD256(v)
case ssaop.OpAMD64VFMADDSUB213PD512:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PD512(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PD512(v)
case ssaop.OpAMD64VFMADDSUB213PDMasked128:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked128(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PDMasked128(v)
case ssaop.OpAMD64VFMADDSUB213PDMasked256:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked256(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PDMasked256(v)
case ssaop.OpAMD64VFMADDSUB213PDMasked512:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked512(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PDMasked512(v)
case ssaop.OpAMD64VFMADDSUB213PS128:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PS128(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PS128(v)
case ssaop.OpAMD64VFMADDSUB213PS256:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PS256(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PS256(v)
case ssaop.OpAMD64VFMADDSUB213PS512:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PS512(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PS512(v)
case ssaop.OpAMD64VFMADDSUB213PSMasked128:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked128(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PSMasked128(v)
case ssaop.OpAMD64VFMADDSUB213PSMasked256:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked256(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PSMasked256(v)
case ssaop.OpAMD64VFMADDSUB213PSMasked512:
- return rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked512(v)
+ return rewriteValue_OpAMD64VFMADDSUB213PSMasked512(v)
case ssaop.OpAMD64VFMSUBADD213PD128:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PD128(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PD128(v)
case ssaop.OpAMD64VFMSUBADD213PD256:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PD256(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PD256(v)
case ssaop.OpAMD64VFMSUBADD213PD512:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PD512(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PD512(v)
case ssaop.OpAMD64VFMSUBADD213PDMasked128:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked128(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PDMasked128(v)
case ssaop.OpAMD64VFMSUBADD213PDMasked256:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked256(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PDMasked256(v)
case ssaop.OpAMD64VFMSUBADD213PDMasked512:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked512(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PDMasked512(v)
case ssaop.OpAMD64VFMSUBADD213PS128:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PS128(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PS128(v)
case ssaop.OpAMD64VFMSUBADD213PS256:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PS256(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PS256(v)
case ssaop.OpAMD64VFMSUBADD213PS512:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PS512(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PS512(v)
case ssaop.OpAMD64VFMSUBADD213PSMasked128:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked128(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PSMasked128(v)
case ssaop.OpAMD64VFMSUBADD213PSMasked256:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked256(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PSMasked256(v)
case ssaop.OpAMD64VFMSUBADD213PSMasked512:
- return rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked512(v)
+ return rewriteValue_OpAMD64VFMSUBADD213PSMasked512(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQB128:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB128(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQB128(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQB256:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB256(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQB256(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQB512:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB512(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQB512(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQBMasked128:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked128(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked128(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQBMasked256:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked256(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked256(v)
case ssaop.OpAMD64VGF2P8AFFINEINVQBMasked512:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked512(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked512(v)
case ssaop.OpAMD64VGF2P8AFFINEQB128:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB128(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQB128(v)
case ssaop.OpAMD64VGF2P8AFFINEQB256:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB256(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQB256(v)
case ssaop.OpAMD64VGF2P8AFFINEQB512:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB512(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQB512(v)
case ssaop.OpAMD64VGF2P8AFFINEQBMasked128:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked128(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQBMasked128(v)
case ssaop.OpAMD64VGF2P8AFFINEQBMasked256:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked256(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQBMasked256(v)
case ssaop.OpAMD64VGF2P8AFFINEQBMasked512:
- return rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked512(v)
+ return rewriteValue_OpAMD64VGF2P8AFFINEQBMasked512(v)
case ssaop.OpAMD64VGF2P8MULB128:
- return rewriteValueAMD64_OpAMD64VGF2P8MULB128(v)
+ return rewriteValue_OpAMD64VGF2P8MULB128(v)
case ssaop.OpAMD64VGF2P8MULB256:
- return rewriteValueAMD64_OpAMD64VGF2P8MULB256(v)
+ return rewriteValue_OpAMD64VGF2P8MULB256(v)
case ssaop.OpAMD64VGF2P8MULBMasked128:
- return rewriteValueAMD64_OpAMD64VGF2P8MULBMasked128(v)
+ return rewriteValue_OpAMD64VGF2P8MULBMasked128(v)
case ssaop.OpAMD64VGF2P8MULBMasked256:
- return rewriteValueAMD64_OpAMD64VGF2P8MULBMasked256(v)
+ return rewriteValue_OpAMD64VGF2P8MULBMasked256(v)
case ssaop.OpAMD64VHADDPD128:
- return rewriteValueAMD64_OpAMD64VHADDPD128(v)
+ return rewriteValue_OpAMD64VHADDPD128(v)
case ssaop.OpAMD64VHADDPD256:
- return rewriteValueAMD64_OpAMD64VHADDPD256(v)
+ return rewriteValue_OpAMD64VHADDPD256(v)
case ssaop.OpAMD64VHADDPS128:
- return rewriteValueAMD64_OpAMD64VHADDPS128(v)
+ return rewriteValue_OpAMD64VHADDPS128(v)
case ssaop.OpAMD64VHADDPS256:
- return rewriteValueAMD64_OpAMD64VHADDPS256(v)
+ return rewriteValue_OpAMD64VHADDPS256(v)
case ssaop.OpAMD64VHSUBPD128:
- return rewriteValueAMD64_OpAMD64VHSUBPD128(v)
+ return rewriteValue_OpAMD64VHSUBPD128(v)
case ssaop.OpAMD64VHSUBPD256:
- return rewriteValueAMD64_OpAMD64VHSUBPD256(v)
+ return rewriteValue_OpAMD64VHSUBPD256(v)
case ssaop.OpAMD64VHSUBPS128:
- return rewriteValueAMD64_OpAMD64VHSUBPS128(v)
+ return rewriteValue_OpAMD64VHSUBPS128(v)
case ssaop.OpAMD64VHSUBPS256:
- return rewriteValueAMD64_OpAMD64VHSUBPS256(v)
+ return rewriteValue_OpAMD64VHSUBPS256(v)
case ssaop.OpAMD64VINSERTF128256:
- return rewriteValueAMD64_OpAMD64VINSERTF128256(v)
+ return rewriteValue_OpAMD64VINSERTF128256(v)
case ssaop.OpAMD64VINSERTF64X4512:
- return rewriteValueAMD64_OpAMD64VINSERTF64X4512(v)
+ return rewriteValue_OpAMD64VINSERTF64X4512(v)
case ssaop.OpAMD64VINSERTI128256:
- return rewriteValueAMD64_OpAMD64VINSERTI128256(v)
+ return rewriteValue_OpAMD64VINSERTI128256(v)
case ssaop.OpAMD64VINSERTI64X4512:
- return rewriteValueAMD64_OpAMD64VINSERTI64X4512(v)
+ return rewriteValue_OpAMD64VINSERTI64X4512(v)
case ssaop.OpAMD64VMAXPD128:
- return rewriteValueAMD64_OpAMD64VMAXPD128(v)
+ return rewriteValue_OpAMD64VMAXPD128(v)
case ssaop.OpAMD64VMAXPD256:
- return rewriteValueAMD64_OpAMD64VMAXPD256(v)
+ return rewriteValue_OpAMD64VMAXPD256(v)
case ssaop.OpAMD64VMAXPD512:
- return rewriteValueAMD64_OpAMD64VMAXPD512(v)
+ return rewriteValue_OpAMD64VMAXPD512(v)
case ssaop.OpAMD64VMAXPDMasked128:
- return rewriteValueAMD64_OpAMD64VMAXPDMasked128(v)
+ return rewriteValue_OpAMD64VMAXPDMasked128(v)
case ssaop.OpAMD64VMAXPDMasked256:
- return rewriteValueAMD64_OpAMD64VMAXPDMasked256(v)
+ return rewriteValue_OpAMD64VMAXPDMasked256(v)
case ssaop.OpAMD64VMAXPDMasked512:
- return rewriteValueAMD64_OpAMD64VMAXPDMasked512(v)
+ return rewriteValue_OpAMD64VMAXPDMasked512(v)
case ssaop.OpAMD64VMAXPS128:
- return rewriteValueAMD64_OpAMD64VMAXPS128(v)
+ return rewriteValue_OpAMD64VMAXPS128(v)
case ssaop.OpAMD64VMAXPS256:
- return rewriteValueAMD64_OpAMD64VMAXPS256(v)
+ return rewriteValue_OpAMD64VMAXPS256(v)
case ssaop.OpAMD64VMAXPS512:
- return rewriteValueAMD64_OpAMD64VMAXPS512(v)
+ return rewriteValue_OpAMD64VMAXPS512(v)
case ssaop.OpAMD64VMAXPSMasked128:
- return rewriteValueAMD64_OpAMD64VMAXPSMasked128(v)
+ return rewriteValue_OpAMD64VMAXPSMasked128(v)
case ssaop.OpAMD64VMAXPSMasked256:
- return rewriteValueAMD64_OpAMD64VMAXPSMasked256(v)
+ return rewriteValue_OpAMD64VMAXPSMasked256(v)
case ssaop.OpAMD64VMAXPSMasked512:
- return rewriteValueAMD64_OpAMD64VMAXPSMasked512(v)
+ return rewriteValue_OpAMD64VMAXPSMasked512(v)
case ssaop.OpAMD64VMINPD128:
- return rewriteValueAMD64_OpAMD64VMINPD128(v)
+ return rewriteValue_OpAMD64VMINPD128(v)
case ssaop.OpAMD64VMINPD256:
- return rewriteValueAMD64_OpAMD64VMINPD256(v)
+ return rewriteValue_OpAMD64VMINPD256(v)
case ssaop.OpAMD64VMINPD512:
- return rewriteValueAMD64_OpAMD64VMINPD512(v)
+ return rewriteValue_OpAMD64VMINPD512(v)
case ssaop.OpAMD64VMINPDMasked128:
- return rewriteValueAMD64_OpAMD64VMINPDMasked128(v)
+ return rewriteValue_OpAMD64VMINPDMasked128(v)
case ssaop.OpAMD64VMINPDMasked256:
- return rewriteValueAMD64_OpAMD64VMINPDMasked256(v)
+ return rewriteValue_OpAMD64VMINPDMasked256(v)
case ssaop.OpAMD64VMINPDMasked512:
- return rewriteValueAMD64_OpAMD64VMINPDMasked512(v)
+ return rewriteValue_OpAMD64VMINPDMasked512(v)
case ssaop.OpAMD64VMINPS128:
- return rewriteValueAMD64_OpAMD64VMINPS128(v)
+ return rewriteValue_OpAMD64VMINPS128(v)
case ssaop.OpAMD64VMINPS256:
- return rewriteValueAMD64_OpAMD64VMINPS256(v)
+ return rewriteValue_OpAMD64VMINPS256(v)
case ssaop.OpAMD64VMINPS512:
- return rewriteValueAMD64_OpAMD64VMINPS512(v)
+ return rewriteValue_OpAMD64VMINPS512(v)
case ssaop.OpAMD64VMINPSMasked128:
- return rewriteValueAMD64_OpAMD64VMINPSMasked128(v)
+ return rewriteValue_OpAMD64VMINPSMasked128(v)
case ssaop.OpAMD64VMINPSMasked256:
- return rewriteValueAMD64_OpAMD64VMINPSMasked256(v)
+ return rewriteValue_OpAMD64VMINPSMasked256(v)
case ssaop.OpAMD64VMINPSMasked512:
- return rewriteValueAMD64_OpAMD64VMINPSMasked512(v)
+ return rewriteValue_OpAMD64VMINPSMasked512(v)
case ssaop.OpAMD64VMOVD:
- return rewriteValueAMD64_OpAMD64VMOVD(v)
+ return rewriteValue_OpAMD64VMOVD(v)
case ssaop.OpAMD64VMOVDQU16Masked128:
- return rewriteValueAMD64_OpAMD64VMOVDQU16Masked128(v)
+ return rewriteValue_OpAMD64VMOVDQU16Masked128(v)
case ssaop.OpAMD64VMOVDQU16Masked256:
- return rewriteValueAMD64_OpAMD64VMOVDQU16Masked256(v)
+ return rewriteValue_OpAMD64VMOVDQU16Masked256(v)
case ssaop.OpAMD64VMOVDQU16Masked512:
- return rewriteValueAMD64_OpAMD64VMOVDQU16Masked512(v)
+ return rewriteValue_OpAMD64VMOVDQU16Masked512(v)
case ssaop.OpAMD64VMOVDQU32Masked128:
- return rewriteValueAMD64_OpAMD64VMOVDQU32Masked128(v)
+ return rewriteValue_OpAMD64VMOVDQU32Masked128(v)
case ssaop.OpAMD64VMOVDQU32Masked256:
- return rewriteValueAMD64_OpAMD64VMOVDQU32Masked256(v)
+ return rewriteValue_OpAMD64VMOVDQU32Masked256(v)
case ssaop.OpAMD64VMOVDQU32Masked512:
- return rewriteValueAMD64_OpAMD64VMOVDQU32Masked512(v)
+ return rewriteValue_OpAMD64VMOVDQU32Masked512(v)
case ssaop.OpAMD64VMOVDQU64Masked128:
- return rewriteValueAMD64_OpAMD64VMOVDQU64Masked128(v)
+ return rewriteValue_OpAMD64VMOVDQU64Masked128(v)
case ssaop.OpAMD64VMOVDQU64Masked256:
- return rewriteValueAMD64_OpAMD64VMOVDQU64Masked256(v)
+ return rewriteValue_OpAMD64VMOVDQU64Masked256(v)
case ssaop.OpAMD64VMOVDQU64Masked512:
- return rewriteValueAMD64_OpAMD64VMOVDQU64Masked512(v)
+ return rewriteValue_OpAMD64VMOVDQU64Masked512(v)
case ssaop.OpAMD64VMOVDQU8Masked128:
- return rewriteValueAMD64_OpAMD64VMOVDQU8Masked128(v)
+ return rewriteValue_OpAMD64VMOVDQU8Masked128(v)
case ssaop.OpAMD64VMOVDQU8Masked256:
- return rewriteValueAMD64_OpAMD64VMOVDQU8Masked256(v)
+ return rewriteValue_OpAMD64VMOVDQU8Masked256(v)
case ssaop.OpAMD64VMOVDQU8Masked512:
- return rewriteValueAMD64_OpAMD64VMOVDQU8Masked512(v)
+ return rewriteValue_OpAMD64VMOVDQU8Masked512(v)
case ssaop.OpAMD64VMOVDQUload128:
- return rewriteValueAMD64_OpAMD64VMOVDQUload128(v)
+ return rewriteValue_OpAMD64VMOVDQUload128(v)
case ssaop.OpAMD64VMOVDQUload256:
- return rewriteValueAMD64_OpAMD64VMOVDQUload256(v)
+ return rewriteValue_OpAMD64VMOVDQUload256(v)
case ssaop.OpAMD64VMOVDQUload512:
- return rewriteValueAMD64_OpAMD64VMOVDQUload512(v)
+ return rewriteValue_OpAMD64VMOVDQUload512(v)
case ssaop.OpAMD64VMOVDQUstore128:
- return rewriteValueAMD64_OpAMD64VMOVDQUstore128(v)
+ return rewriteValue_OpAMD64VMOVDQUstore128(v)
case ssaop.OpAMD64VMOVDQUstore256:
- return rewriteValueAMD64_OpAMD64VMOVDQUstore256(v)
+ return rewriteValue_OpAMD64VMOVDQUstore256(v)
case ssaop.OpAMD64VMOVDQUstore512:
- return rewriteValueAMD64_OpAMD64VMOVDQUstore512(v)
+ return rewriteValue_OpAMD64VMOVDQUstore512(v)
case ssaop.OpAMD64VMOVQ:
- return rewriteValueAMD64_OpAMD64VMOVQ(v)
+ return rewriteValue_OpAMD64VMOVQ(v)
case ssaop.OpAMD64VMOVSDf2v:
- return rewriteValueAMD64_OpAMD64VMOVSDf2v(v)
+ return rewriteValue_OpAMD64VMOVSDf2v(v)
case ssaop.OpAMD64VMOVSSf2v:
- return rewriteValueAMD64_OpAMD64VMOVSSf2v(v)
+ return rewriteValue_OpAMD64VMOVSSf2v(v)
case ssaop.OpAMD64VMULPD128:
- return rewriteValueAMD64_OpAMD64VMULPD128(v)
+ return rewriteValue_OpAMD64VMULPD128(v)
case ssaop.OpAMD64VMULPD256:
- return rewriteValueAMD64_OpAMD64VMULPD256(v)
+ return rewriteValue_OpAMD64VMULPD256(v)
case ssaop.OpAMD64VMULPD512:
- return rewriteValueAMD64_OpAMD64VMULPD512(v)
+ return rewriteValue_OpAMD64VMULPD512(v)
case ssaop.OpAMD64VMULPDMasked128:
- return rewriteValueAMD64_OpAMD64VMULPDMasked128(v)
+ return rewriteValue_OpAMD64VMULPDMasked128(v)
case ssaop.OpAMD64VMULPDMasked256:
- return rewriteValueAMD64_OpAMD64VMULPDMasked256(v)
+ return rewriteValue_OpAMD64VMULPDMasked256(v)
case ssaop.OpAMD64VMULPDMasked512:
- return rewriteValueAMD64_OpAMD64VMULPDMasked512(v)
+ return rewriteValue_OpAMD64VMULPDMasked512(v)
case ssaop.OpAMD64VMULPS128:
- return rewriteValueAMD64_OpAMD64VMULPS128(v)
+ return rewriteValue_OpAMD64VMULPS128(v)
case ssaop.OpAMD64VMULPS256:
- return rewriteValueAMD64_OpAMD64VMULPS256(v)
+ return rewriteValue_OpAMD64VMULPS256(v)
case ssaop.OpAMD64VMULPS512:
- return rewriteValueAMD64_OpAMD64VMULPS512(v)
+ return rewriteValue_OpAMD64VMULPS512(v)
case ssaop.OpAMD64VMULPSMasked128:
- return rewriteValueAMD64_OpAMD64VMULPSMasked128(v)
+ return rewriteValue_OpAMD64VMULPSMasked128(v)
case ssaop.OpAMD64VMULPSMasked256:
- return rewriteValueAMD64_OpAMD64VMULPSMasked256(v)
+ return rewriteValue_OpAMD64VMULPSMasked256(v)
case ssaop.OpAMD64VMULPSMasked512:
- return rewriteValueAMD64_OpAMD64VMULPSMasked512(v)
+ return rewriteValue_OpAMD64VMULPSMasked512(v)
case ssaop.OpAMD64VPABSB128:
- return rewriteValueAMD64_OpAMD64VPABSB128(v)
+ return rewriteValue_OpAMD64VPABSB128(v)
case ssaop.OpAMD64VPABSB256:
- return rewriteValueAMD64_OpAMD64VPABSB256(v)
+ return rewriteValue_OpAMD64VPABSB256(v)
case ssaop.OpAMD64VPABSBMasked128:
- return rewriteValueAMD64_OpAMD64VPABSBMasked128(v)
+ return rewriteValue_OpAMD64VPABSBMasked128(v)
case ssaop.OpAMD64VPABSBMasked256:
- return rewriteValueAMD64_OpAMD64VPABSBMasked256(v)
+ return rewriteValue_OpAMD64VPABSBMasked256(v)
case ssaop.OpAMD64VPABSD128:
- return rewriteValueAMD64_OpAMD64VPABSD128(v)
+ return rewriteValue_OpAMD64VPABSD128(v)
case ssaop.OpAMD64VPABSD256:
- return rewriteValueAMD64_OpAMD64VPABSD256(v)
+ return rewriteValue_OpAMD64VPABSD256(v)
case ssaop.OpAMD64VPABSD512:
- return rewriteValueAMD64_OpAMD64VPABSD512(v)
+ return rewriteValue_OpAMD64VPABSD512(v)
case ssaop.OpAMD64VPABSDMasked128:
- return rewriteValueAMD64_OpAMD64VPABSDMasked128(v)
+ return rewriteValue_OpAMD64VPABSDMasked128(v)
case ssaop.OpAMD64VPABSDMasked256:
- return rewriteValueAMD64_OpAMD64VPABSDMasked256(v)
+ return rewriteValue_OpAMD64VPABSDMasked256(v)
case ssaop.OpAMD64VPABSDMasked512:
- return rewriteValueAMD64_OpAMD64VPABSDMasked512(v)
+ return rewriteValue_OpAMD64VPABSDMasked512(v)
case ssaop.OpAMD64VPABSQ128:
- return rewriteValueAMD64_OpAMD64VPABSQ128(v)
+ return rewriteValue_OpAMD64VPABSQ128(v)
case ssaop.OpAMD64VPABSQ256:
- return rewriteValueAMD64_OpAMD64VPABSQ256(v)
+ return rewriteValue_OpAMD64VPABSQ256(v)
case ssaop.OpAMD64VPABSQ512:
- return rewriteValueAMD64_OpAMD64VPABSQ512(v)
+ return rewriteValue_OpAMD64VPABSQ512(v)
case ssaop.OpAMD64VPABSQMasked128:
- return rewriteValueAMD64_OpAMD64VPABSQMasked128(v)
+ return rewriteValue_OpAMD64VPABSQMasked128(v)
case ssaop.OpAMD64VPABSQMasked256:
- return rewriteValueAMD64_OpAMD64VPABSQMasked256(v)
+ return rewriteValue_OpAMD64VPABSQMasked256(v)
case ssaop.OpAMD64VPABSQMasked512:
- return rewriteValueAMD64_OpAMD64VPABSQMasked512(v)
+ return rewriteValue_OpAMD64VPABSQMasked512(v)
case ssaop.OpAMD64VPABSW128:
- return rewriteValueAMD64_OpAMD64VPABSW128(v)
+ return rewriteValue_OpAMD64VPABSW128(v)
case ssaop.OpAMD64VPABSW256:
- return rewriteValueAMD64_OpAMD64VPABSW256(v)
+ return rewriteValue_OpAMD64VPABSW256(v)
case ssaop.OpAMD64VPABSWMasked128:
- return rewriteValueAMD64_OpAMD64VPABSWMasked128(v)
+ return rewriteValue_OpAMD64VPABSWMasked128(v)
case ssaop.OpAMD64VPABSWMasked256:
- return rewriteValueAMD64_OpAMD64VPABSWMasked256(v)
+ return rewriteValue_OpAMD64VPABSWMasked256(v)
case ssaop.OpAMD64VPACKSSDW128:
- return rewriteValueAMD64_OpAMD64VPACKSSDW128(v)
+ return rewriteValue_OpAMD64VPACKSSDW128(v)
case ssaop.OpAMD64VPACKSSDW256:
- return rewriteValueAMD64_OpAMD64VPACKSSDW256(v)
+ return rewriteValue_OpAMD64VPACKSSDW256(v)
case ssaop.OpAMD64VPACKSSDW512:
- return rewriteValueAMD64_OpAMD64VPACKSSDW512(v)
+ return rewriteValue_OpAMD64VPACKSSDW512(v)
case ssaop.OpAMD64VPACKSSDWMasked128:
- return rewriteValueAMD64_OpAMD64VPACKSSDWMasked128(v)
+ return rewriteValue_OpAMD64VPACKSSDWMasked128(v)
case ssaop.OpAMD64VPACKSSDWMasked256:
- return rewriteValueAMD64_OpAMD64VPACKSSDWMasked256(v)
+ return rewriteValue_OpAMD64VPACKSSDWMasked256(v)
case ssaop.OpAMD64VPACKSSDWMasked512:
- return rewriteValueAMD64_OpAMD64VPACKSSDWMasked512(v)
+ return rewriteValue_OpAMD64VPACKSSDWMasked512(v)
case ssaop.OpAMD64VPACKUSDW128:
- return rewriteValueAMD64_OpAMD64VPACKUSDW128(v)
+ return rewriteValue_OpAMD64VPACKUSDW128(v)
case ssaop.OpAMD64VPACKUSDW256:
- return rewriteValueAMD64_OpAMD64VPACKUSDW256(v)
+ return rewriteValue_OpAMD64VPACKUSDW256(v)
case ssaop.OpAMD64VPACKUSDW512:
- return rewriteValueAMD64_OpAMD64VPACKUSDW512(v)
+ return rewriteValue_OpAMD64VPACKUSDW512(v)
case ssaop.OpAMD64VPACKUSDWMasked128:
- return rewriteValueAMD64_OpAMD64VPACKUSDWMasked128(v)
+ return rewriteValue_OpAMD64VPACKUSDWMasked128(v)
case ssaop.OpAMD64VPACKUSDWMasked256:
- return rewriteValueAMD64_OpAMD64VPACKUSDWMasked256(v)
+ return rewriteValue_OpAMD64VPACKUSDWMasked256(v)
case ssaop.OpAMD64VPACKUSDWMasked512:
- return rewriteValueAMD64_OpAMD64VPACKUSDWMasked512(v)
+ return rewriteValue_OpAMD64VPACKUSDWMasked512(v)
case ssaop.OpAMD64VPADDB128:
- return rewriteValueAMD64_OpAMD64VPADDB128(v)
+ return rewriteValue_OpAMD64VPADDB128(v)
case ssaop.OpAMD64VPADDB256:
- return rewriteValueAMD64_OpAMD64VPADDB256(v)
+ return rewriteValue_OpAMD64VPADDB256(v)
case ssaop.OpAMD64VPADDBMasked128:
- return rewriteValueAMD64_OpAMD64VPADDBMasked128(v)
+ return rewriteValue_OpAMD64VPADDBMasked128(v)
case ssaop.OpAMD64VPADDBMasked256:
- return rewriteValueAMD64_OpAMD64VPADDBMasked256(v)
+ return rewriteValue_OpAMD64VPADDBMasked256(v)
case ssaop.OpAMD64VPADDD128:
- return rewriteValueAMD64_OpAMD64VPADDD128(v)
+ return rewriteValue_OpAMD64VPADDD128(v)
case ssaop.OpAMD64VPADDD256:
- return rewriteValueAMD64_OpAMD64VPADDD256(v)
+ return rewriteValue_OpAMD64VPADDD256(v)
case ssaop.OpAMD64VPADDD512:
- return rewriteValueAMD64_OpAMD64VPADDD512(v)
+ return rewriteValue_OpAMD64VPADDD512(v)
case ssaop.OpAMD64VPADDDMasked128:
- return rewriteValueAMD64_OpAMD64VPADDDMasked128(v)
+ return rewriteValue_OpAMD64VPADDDMasked128(v)
case ssaop.OpAMD64VPADDDMasked256:
- return rewriteValueAMD64_OpAMD64VPADDDMasked256(v)
+ return rewriteValue_OpAMD64VPADDDMasked256(v)
case ssaop.OpAMD64VPADDDMasked512:
- return rewriteValueAMD64_OpAMD64VPADDDMasked512(v)
+ return rewriteValue_OpAMD64VPADDDMasked512(v)
case ssaop.OpAMD64VPADDQ128:
- return rewriteValueAMD64_OpAMD64VPADDQ128(v)
+ return rewriteValue_OpAMD64VPADDQ128(v)
case ssaop.OpAMD64VPADDQ256:
- return rewriteValueAMD64_OpAMD64VPADDQ256(v)
+ return rewriteValue_OpAMD64VPADDQ256(v)
case ssaop.OpAMD64VPADDQ512:
- return rewriteValueAMD64_OpAMD64VPADDQ512(v)
+ return rewriteValue_OpAMD64VPADDQ512(v)
case ssaop.OpAMD64VPADDQMasked128:
- return rewriteValueAMD64_OpAMD64VPADDQMasked128(v)
+ return rewriteValue_OpAMD64VPADDQMasked128(v)
case ssaop.OpAMD64VPADDQMasked256:
- return rewriteValueAMD64_OpAMD64VPADDQMasked256(v)
+ return rewriteValue_OpAMD64VPADDQMasked256(v)
case ssaop.OpAMD64VPADDQMasked512:
- return rewriteValueAMD64_OpAMD64VPADDQMasked512(v)
+ return rewriteValue_OpAMD64VPADDQMasked512(v)
case ssaop.OpAMD64VPADDSB128:
- return rewriteValueAMD64_OpAMD64VPADDSB128(v)
+ return rewriteValue_OpAMD64VPADDSB128(v)
case ssaop.OpAMD64VPADDSB256:
- return rewriteValueAMD64_OpAMD64VPADDSB256(v)
+ return rewriteValue_OpAMD64VPADDSB256(v)
case ssaop.OpAMD64VPADDSBMasked128:
- return rewriteValueAMD64_OpAMD64VPADDSBMasked128(v)
+ return rewriteValue_OpAMD64VPADDSBMasked128(v)
case ssaop.OpAMD64VPADDSBMasked256:
- return rewriteValueAMD64_OpAMD64VPADDSBMasked256(v)
+ return rewriteValue_OpAMD64VPADDSBMasked256(v)
case ssaop.OpAMD64VPADDSW128:
- return rewriteValueAMD64_OpAMD64VPADDSW128(v)
+ return rewriteValue_OpAMD64VPADDSW128(v)
case ssaop.OpAMD64VPADDSW256:
- return rewriteValueAMD64_OpAMD64VPADDSW256(v)
+ return rewriteValue_OpAMD64VPADDSW256(v)
case ssaop.OpAMD64VPADDSWMasked128:
- return rewriteValueAMD64_OpAMD64VPADDSWMasked128(v)
+ return rewriteValue_OpAMD64VPADDSWMasked128(v)
case ssaop.OpAMD64VPADDSWMasked256:
- return rewriteValueAMD64_OpAMD64VPADDSWMasked256(v)
+ return rewriteValue_OpAMD64VPADDSWMasked256(v)
case ssaop.OpAMD64VPADDUSB128:
- return rewriteValueAMD64_OpAMD64VPADDUSB128(v)
+ return rewriteValue_OpAMD64VPADDUSB128(v)
case ssaop.OpAMD64VPADDUSB256:
- return rewriteValueAMD64_OpAMD64VPADDUSB256(v)
+ return rewriteValue_OpAMD64VPADDUSB256(v)
case ssaop.OpAMD64VPADDUSBMasked128:
- return rewriteValueAMD64_OpAMD64VPADDUSBMasked128(v)
+ return rewriteValue_OpAMD64VPADDUSBMasked128(v)
case ssaop.OpAMD64VPADDUSBMasked256:
- return rewriteValueAMD64_OpAMD64VPADDUSBMasked256(v)
+ return rewriteValue_OpAMD64VPADDUSBMasked256(v)
case ssaop.OpAMD64VPADDUSW128:
- return rewriteValueAMD64_OpAMD64VPADDUSW128(v)
+ return rewriteValue_OpAMD64VPADDUSW128(v)
case ssaop.OpAMD64VPADDUSW256:
- return rewriteValueAMD64_OpAMD64VPADDUSW256(v)
+ return rewriteValue_OpAMD64VPADDUSW256(v)
case ssaop.OpAMD64VPADDUSWMasked128:
- return rewriteValueAMD64_OpAMD64VPADDUSWMasked128(v)
+ return rewriteValue_OpAMD64VPADDUSWMasked128(v)
case ssaop.OpAMD64VPADDUSWMasked256:
- return rewriteValueAMD64_OpAMD64VPADDUSWMasked256(v)
+ return rewriteValue_OpAMD64VPADDUSWMasked256(v)
case ssaop.OpAMD64VPADDW128:
- return rewriteValueAMD64_OpAMD64VPADDW128(v)
+ return rewriteValue_OpAMD64VPADDW128(v)
case ssaop.OpAMD64VPADDW256:
- return rewriteValueAMD64_OpAMD64VPADDW256(v)
+ return rewriteValue_OpAMD64VPADDW256(v)
case ssaop.OpAMD64VPADDWMasked128:
- return rewriteValueAMD64_OpAMD64VPADDWMasked128(v)
+ return rewriteValue_OpAMD64VPADDWMasked128(v)
case ssaop.OpAMD64VPADDWMasked256:
- return rewriteValueAMD64_OpAMD64VPADDWMasked256(v)
+ return rewriteValue_OpAMD64VPADDWMasked256(v)
case ssaop.OpAMD64VPALIGNR128:
- return rewriteValueAMD64_OpAMD64VPALIGNR128(v)
+ return rewriteValue_OpAMD64VPALIGNR128(v)
case ssaop.OpAMD64VPALIGNR256:
- return rewriteValueAMD64_OpAMD64VPALIGNR256(v)
+ return rewriteValue_OpAMD64VPALIGNR256(v)
case ssaop.OpAMD64VPALIGNRMasked128:
- return rewriteValueAMD64_OpAMD64VPALIGNRMasked128(v)
+ return rewriteValue_OpAMD64VPALIGNRMasked128(v)
case ssaop.OpAMD64VPALIGNRMasked256:
- return rewriteValueAMD64_OpAMD64VPALIGNRMasked256(v)
+ return rewriteValue_OpAMD64VPALIGNRMasked256(v)
case ssaop.OpAMD64VPAND128:
- return rewriteValueAMD64_OpAMD64VPAND128(v)
+ return rewriteValue_OpAMD64VPAND128(v)
case ssaop.OpAMD64VPAND256:
- return rewriteValueAMD64_OpAMD64VPAND256(v)
+ return rewriteValue_OpAMD64VPAND256(v)
case ssaop.OpAMD64VPANDD512:
- return rewriteValueAMD64_OpAMD64VPANDD512(v)
+ return rewriteValue_OpAMD64VPANDD512(v)
case ssaop.OpAMD64VPANDDMasked128:
- return rewriteValueAMD64_OpAMD64VPANDDMasked128(v)
+ return rewriteValue_OpAMD64VPANDDMasked128(v)
case ssaop.OpAMD64VPANDDMasked256:
- return rewriteValueAMD64_OpAMD64VPANDDMasked256(v)
+ return rewriteValue_OpAMD64VPANDDMasked256(v)
case ssaop.OpAMD64VPANDDMasked512:
- return rewriteValueAMD64_OpAMD64VPANDDMasked512(v)
+ return rewriteValue_OpAMD64VPANDDMasked512(v)
case ssaop.OpAMD64VPANDN128:
- return rewriteValueAMD64_OpAMD64VPANDN128(v)
+ return rewriteValue_OpAMD64VPANDN128(v)
case ssaop.OpAMD64VPANDN256:
- return rewriteValueAMD64_OpAMD64VPANDN256(v)
+ return rewriteValue_OpAMD64VPANDN256(v)
case ssaop.OpAMD64VPANDND512:
- return rewriteValueAMD64_OpAMD64VPANDND512(v)
+ return rewriteValue_OpAMD64VPANDND512(v)
case ssaop.OpAMD64VPANDNDMasked128:
- return rewriteValueAMD64_OpAMD64VPANDNDMasked128(v)
+ return rewriteValue_OpAMD64VPANDNDMasked128(v)
case ssaop.OpAMD64VPANDNDMasked256:
- return rewriteValueAMD64_OpAMD64VPANDNDMasked256(v)
+ return rewriteValue_OpAMD64VPANDNDMasked256(v)
case ssaop.OpAMD64VPANDNDMasked512:
- return rewriteValueAMD64_OpAMD64VPANDNDMasked512(v)
+ return rewriteValue_OpAMD64VPANDNDMasked512(v)
case ssaop.OpAMD64VPANDNQ512:
- return rewriteValueAMD64_OpAMD64VPANDNQ512(v)
+ return rewriteValue_OpAMD64VPANDNQ512(v)
case ssaop.OpAMD64VPANDNQMasked128:
- return rewriteValueAMD64_OpAMD64VPANDNQMasked128(v)
+ return rewriteValue_OpAMD64VPANDNQMasked128(v)
case ssaop.OpAMD64VPANDNQMasked256:
- return rewriteValueAMD64_OpAMD64VPANDNQMasked256(v)
+ return rewriteValue_OpAMD64VPANDNQMasked256(v)
case ssaop.OpAMD64VPANDNQMasked512:
- return rewriteValueAMD64_OpAMD64VPANDNQMasked512(v)
+ return rewriteValue_OpAMD64VPANDNQMasked512(v)
case ssaop.OpAMD64VPANDQ512:
- return rewriteValueAMD64_OpAMD64VPANDQ512(v)
+ return rewriteValue_OpAMD64VPANDQ512(v)
case ssaop.OpAMD64VPANDQMasked128:
- return rewriteValueAMD64_OpAMD64VPANDQMasked128(v)
+ return rewriteValue_OpAMD64VPANDQMasked128(v)
case ssaop.OpAMD64VPANDQMasked256:
- return rewriteValueAMD64_OpAMD64VPANDQMasked256(v)
+ return rewriteValue_OpAMD64VPANDQMasked256(v)
case ssaop.OpAMD64VPANDQMasked512:
- return rewriteValueAMD64_OpAMD64VPANDQMasked512(v)
+ return rewriteValue_OpAMD64VPANDQMasked512(v)
case ssaop.OpAMD64VPAVGB128:
- return rewriteValueAMD64_OpAMD64VPAVGB128(v)
+ return rewriteValue_OpAMD64VPAVGB128(v)
case ssaop.OpAMD64VPAVGB256:
- return rewriteValueAMD64_OpAMD64VPAVGB256(v)
+ return rewriteValue_OpAMD64VPAVGB256(v)
case ssaop.OpAMD64VPAVGBMasked128:
- return rewriteValueAMD64_OpAMD64VPAVGBMasked128(v)
+ return rewriteValue_OpAMD64VPAVGBMasked128(v)
case ssaop.OpAMD64VPAVGBMasked256:
- return rewriteValueAMD64_OpAMD64VPAVGBMasked256(v)
+ return rewriteValue_OpAMD64VPAVGBMasked256(v)
case ssaop.OpAMD64VPAVGW128:
- return rewriteValueAMD64_OpAMD64VPAVGW128(v)
+ return rewriteValue_OpAMD64VPAVGW128(v)
case ssaop.OpAMD64VPAVGW256:
- return rewriteValueAMD64_OpAMD64VPAVGW256(v)
+ return rewriteValue_OpAMD64VPAVGW256(v)
case ssaop.OpAMD64VPAVGWMasked128:
- return rewriteValueAMD64_OpAMD64VPAVGWMasked128(v)
+ return rewriteValue_OpAMD64VPAVGWMasked128(v)
case ssaop.OpAMD64VPAVGWMasked256:
- return rewriteValueAMD64_OpAMD64VPAVGWMasked256(v)
+ return rewriteValue_OpAMD64VPAVGWMasked256(v)
case ssaop.OpAMD64VPBLENDMBMasked512:
- return rewriteValueAMD64_OpAMD64VPBLENDMBMasked512(v)
+ return rewriteValue_OpAMD64VPBLENDMBMasked512(v)
case ssaop.OpAMD64VPBLENDMDMasked512:
- return rewriteValueAMD64_OpAMD64VPBLENDMDMasked512(v)
+ return rewriteValue_OpAMD64VPBLENDMDMasked512(v)
case ssaop.OpAMD64VPBLENDMQMasked512:
- return rewriteValueAMD64_OpAMD64VPBLENDMQMasked512(v)
+ return rewriteValue_OpAMD64VPBLENDMQMasked512(v)
case ssaop.OpAMD64VPBLENDMWMasked512:
- return rewriteValueAMD64_OpAMD64VPBLENDMWMasked512(v)
+ return rewriteValue_OpAMD64VPBLENDMWMasked512(v)
case ssaop.OpAMD64VPBLENDVB128:
- return rewriteValueAMD64_OpAMD64VPBLENDVB128(v)
+ return rewriteValue_OpAMD64VPBLENDVB128(v)
case ssaop.OpAMD64VPBLENDVB256:
- return rewriteValueAMD64_OpAMD64VPBLENDVB256(v)
+ return rewriteValue_OpAMD64VPBLENDVB256(v)
case ssaop.OpAMD64VPBROADCASTB128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTB128(v)
+ return rewriteValue_OpAMD64VPBROADCASTB128(v)
case ssaop.OpAMD64VPBROADCASTB256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTB256(v)
+ return rewriteValue_OpAMD64VPBROADCASTB256(v)
case ssaop.OpAMD64VPBROADCASTB512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTB512(v)
+ return rewriteValue_OpAMD64VPBROADCASTB512(v)
case ssaop.OpAMD64VPBROADCASTBMasked128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTBMasked128(v)
+ return rewriteValue_OpAMD64VPBROADCASTBMasked128(v)
case ssaop.OpAMD64VPBROADCASTBMasked256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTBMasked256(v)
+ return rewriteValue_OpAMD64VPBROADCASTBMasked256(v)
case ssaop.OpAMD64VPBROADCASTBMasked512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTBMasked512(v)
+ return rewriteValue_OpAMD64VPBROADCASTBMasked512(v)
case ssaop.OpAMD64VPBROADCASTD128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTD128(v)
+ return rewriteValue_OpAMD64VPBROADCASTD128(v)
case ssaop.OpAMD64VPBROADCASTD256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTD256(v)
+ return rewriteValue_OpAMD64VPBROADCASTD256(v)
case ssaop.OpAMD64VPBROADCASTD512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTD512(v)
+ return rewriteValue_OpAMD64VPBROADCASTD512(v)
case ssaop.OpAMD64VPBROADCASTDMasked128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTDMasked128(v)
+ return rewriteValue_OpAMD64VPBROADCASTDMasked128(v)
case ssaop.OpAMD64VPBROADCASTDMasked256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTDMasked256(v)
+ return rewriteValue_OpAMD64VPBROADCASTDMasked256(v)
case ssaop.OpAMD64VPBROADCASTDMasked512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTDMasked512(v)
+ return rewriteValue_OpAMD64VPBROADCASTDMasked512(v)
case ssaop.OpAMD64VPBROADCASTQ128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQ128(v)
+ return rewriteValue_OpAMD64VPBROADCASTQ128(v)
case ssaop.OpAMD64VPBROADCASTQ256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQ256(v)
+ return rewriteValue_OpAMD64VPBROADCASTQ256(v)
case ssaop.OpAMD64VPBROADCASTQ512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQ512(v)
+ return rewriteValue_OpAMD64VPBROADCASTQ512(v)
case ssaop.OpAMD64VPBROADCASTQMasked128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQMasked128(v)
+ return rewriteValue_OpAMD64VPBROADCASTQMasked128(v)
case ssaop.OpAMD64VPBROADCASTQMasked256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQMasked256(v)
+ return rewriteValue_OpAMD64VPBROADCASTQMasked256(v)
case ssaop.OpAMD64VPBROADCASTQMasked512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTQMasked512(v)
+ return rewriteValue_OpAMD64VPBROADCASTQMasked512(v)
case ssaop.OpAMD64VPBROADCASTW128:
- return rewriteValueAMD64_OpAMD64VPBROADCASTW128(v)
+ return rewriteValue_OpAMD64VPBROADCASTW128(v)
case ssaop.OpAMD64VPBROADCASTW256:
- return rewriteValueAMD64_OpAMD64VPBROADCASTW256(v)
+ return rewriteValue_OpAMD64VPBROADCASTW256(v)
case ssaop.OpAMD64VPBROADCASTW512:
- return rewriteValueAMD64_OpAMD64VPBROADCASTW512(v)
+ return rewriteValue_OpAMD64VPBROADCASTW512(v)
case ssaop.OpAMD64VPCLMULQDQ128:
- return rewriteValueAMD64_OpAMD64VPCLMULQDQ128(v)
+ return rewriteValue_OpAMD64VPCLMULQDQ128(v)
case ssaop.OpAMD64VPCLMULQDQ256:
- return rewriteValueAMD64_OpAMD64VPCLMULQDQ256(v)
+ return rewriteValue_OpAMD64VPCLMULQDQ256(v)
case ssaop.OpAMD64VPCMPBMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPBMasked128(v)
+ return rewriteValue_OpAMD64VPCMPBMasked128(v)
case ssaop.OpAMD64VPCMPBMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPBMasked256(v)
+ return rewriteValue_OpAMD64VPCMPBMasked256(v)
case ssaop.OpAMD64VPCMPD512:
- return rewriteValueAMD64_OpAMD64VPCMPD512(v)
+ return rewriteValue_OpAMD64VPCMPD512(v)
case ssaop.OpAMD64VPCMPDMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPDMasked128(v)
+ return rewriteValue_OpAMD64VPCMPDMasked128(v)
case ssaop.OpAMD64VPCMPDMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPDMasked256(v)
+ return rewriteValue_OpAMD64VPCMPDMasked256(v)
case ssaop.OpAMD64VPCMPDMasked512:
- return rewriteValueAMD64_OpAMD64VPCMPDMasked512(v)
+ return rewriteValue_OpAMD64VPCMPDMasked512(v)
case ssaop.OpAMD64VPCMPEQB128:
- return rewriteValueAMD64_OpAMD64VPCMPEQB128(v)
+ return rewriteValue_OpAMD64VPCMPEQB128(v)
case ssaop.OpAMD64VPCMPEQB256:
- return rewriteValueAMD64_OpAMD64VPCMPEQB256(v)
+ return rewriteValue_OpAMD64VPCMPEQB256(v)
case ssaop.OpAMD64VPCMPEQD128:
- return rewriteValueAMD64_OpAMD64VPCMPEQD128(v)
+ return rewriteValue_OpAMD64VPCMPEQD128(v)
case ssaop.OpAMD64VPCMPEQD256:
- return rewriteValueAMD64_OpAMD64VPCMPEQD256(v)
+ return rewriteValue_OpAMD64VPCMPEQD256(v)
case ssaop.OpAMD64VPCMPEQD512:
- return rewriteValueAMD64_OpAMD64VPCMPEQD512(v)
+ return rewriteValue_OpAMD64VPCMPEQD512(v)
case ssaop.OpAMD64VPCMPEQQ128:
- return rewriteValueAMD64_OpAMD64VPCMPEQQ128(v)
+ return rewriteValue_OpAMD64VPCMPEQQ128(v)
case ssaop.OpAMD64VPCMPEQQ256:
- return rewriteValueAMD64_OpAMD64VPCMPEQQ256(v)
+ return rewriteValue_OpAMD64VPCMPEQQ256(v)
case ssaop.OpAMD64VPCMPEQQ512:
- return rewriteValueAMD64_OpAMD64VPCMPEQQ512(v)
+ return rewriteValue_OpAMD64VPCMPEQQ512(v)
case ssaop.OpAMD64VPCMPEQW128:
- return rewriteValueAMD64_OpAMD64VPCMPEQW128(v)
+ return rewriteValue_OpAMD64VPCMPEQW128(v)
case ssaop.OpAMD64VPCMPEQW256:
- return rewriteValueAMD64_OpAMD64VPCMPEQW256(v)
+ return rewriteValue_OpAMD64VPCMPEQW256(v)
case ssaop.OpAMD64VPCMPGTB128:
- return rewriteValueAMD64_OpAMD64VPCMPGTB128(v)
+ return rewriteValue_OpAMD64VPCMPGTB128(v)
case ssaop.OpAMD64VPCMPGTB256:
- return rewriteValueAMD64_OpAMD64VPCMPGTB256(v)
+ return rewriteValue_OpAMD64VPCMPGTB256(v)
case ssaop.OpAMD64VPCMPGTD128:
- return rewriteValueAMD64_OpAMD64VPCMPGTD128(v)
+ return rewriteValue_OpAMD64VPCMPGTD128(v)
case ssaop.OpAMD64VPCMPGTD256:
- return rewriteValueAMD64_OpAMD64VPCMPGTD256(v)
+ return rewriteValue_OpAMD64VPCMPGTD256(v)
case ssaop.OpAMD64VPCMPGTD512:
- return rewriteValueAMD64_OpAMD64VPCMPGTD512(v)
+ return rewriteValue_OpAMD64VPCMPGTD512(v)
case ssaop.OpAMD64VPCMPGTQ128:
- return rewriteValueAMD64_OpAMD64VPCMPGTQ128(v)
+ return rewriteValue_OpAMD64VPCMPGTQ128(v)
case ssaop.OpAMD64VPCMPGTQ256:
- return rewriteValueAMD64_OpAMD64VPCMPGTQ256(v)
+ return rewriteValue_OpAMD64VPCMPGTQ256(v)
case ssaop.OpAMD64VPCMPGTQ512:
- return rewriteValueAMD64_OpAMD64VPCMPGTQ512(v)
+ return rewriteValue_OpAMD64VPCMPGTQ512(v)
case ssaop.OpAMD64VPCMPGTW128:
- return rewriteValueAMD64_OpAMD64VPCMPGTW128(v)
+ return rewriteValue_OpAMD64VPCMPGTW128(v)
case ssaop.OpAMD64VPCMPGTW256:
- return rewriteValueAMD64_OpAMD64VPCMPGTW256(v)
+ return rewriteValue_OpAMD64VPCMPGTW256(v)
case ssaop.OpAMD64VPCMPQ512:
- return rewriteValueAMD64_OpAMD64VPCMPQ512(v)
+ return rewriteValue_OpAMD64VPCMPQ512(v)
case ssaop.OpAMD64VPCMPQMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPQMasked128(v)
+ return rewriteValue_OpAMD64VPCMPQMasked128(v)
case ssaop.OpAMD64VPCMPQMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPQMasked256(v)
+ return rewriteValue_OpAMD64VPCMPQMasked256(v)
case ssaop.OpAMD64VPCMPQMasked512:
- return rewriteValueAMD64_OpAMD64VPCMPQMasked512(v)
+ return rewriteValue_OpAMD64VPCMPQMasked512(v)
case ssaop.OpAMD64VPCMPUBMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPUBMasked128(v)
+ return rewriteValue_OpAMD64VPCMPUBMasked128(v)
case ssaop.OpAMD64VPCMPUBMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPUBMasked256(v)
+ return rewriteValue_OpAMD64VPCMPUBMasked256(v)
case ssaop.OpAMD64VPCMPUD512:
- return rewriteValueAMD64_OpAMD64VPCMPUD512(v)
+ return rewriteValue_OpAMD64VPCMPUD512(v)
case ssaop.OpAMD64VPCMPUDMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPUDMasked128(v)
+ return rewriteValue_OpAMD64VPCMPUDMasked128(v)
case ssaop.OpAMD64VPCMPUDMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPUDMasked256(v)
+ return rewriteValue_OpAMD64VPCMPUDMasked256(v)
case ssaop.OpAMD64VPCMPUDMasked512:
- return rewriteValueAMD64_OpAMD64VPCMPUDMasked512(v)
+ return rewriteValue_OpAMD64VPCMPUDMasked512(v)
case ssaop.OpAMD64VPCMPUQ512:
- return rewriteValueAMD64_OpAMD64VPCMPUQ512(v)
+ return rewriteValue_OpAMD64VPCMPUQ512(v)
case ssaop.OpAMD64VPCMPUQMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPUQMasked128(v)
+ return rewriteValue_OpAMD64VPCMPUQMasked128(v)
case ssaop.OpAMD64VPCMPUQMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPUQMasked256(v)
+ return rewriteValue_OpAMD64VPCMPUQMasked256(v)
case ssaop.OpAMD64VPCMPUQMasked512:
- return rewriteValueAMD64_OpAMD64VPCMPUQMasked512(v)
+ return rewriteValue_OpAMD64VPCMPUQMasked512(v)
case ssaop.OpAMD64VPCMPUWMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPUWMasked128(v)
+ return rewriteValue_OpAMD64VPCMPUWMasked128(v)
case ssaop.OpAMD64VPCMPUWMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPUWMasked256(v)
+ return rewriteValue_OpAMD64VPCMPUWMasked256(v)
case ssaop.OpAMD64VPCMPWMasked128:
- return rewriteValueAMD64_OpAMD64VPCMPWMasked128(v)
+ return rewriteValue_OpAMD64VPCMPWMasked128(v)
case ssaop.OpAMD64VPCMPWMasked256:
- return rewriteValueAMD64_OpAMD64VPCMPWMasked256(v)
+ return rewriteValue_OpAMD64VPCMPWMasked256(v)
case ssaop.OpAMD64VPDPWSSD128:
- return rewriteValueAMD64_OpAMD64VPDPWSSD128(v)
+ return rewriteValue_OpAMD64VPDPWSSD128(v)
case ssaop.OpAMD64VPDPWSSD256:
- return rewriteValueAMD64_OpAMD64VPDPWSSD256(v)
+ return rewriteValue_OpAMD64VPDPWSSD256(v)
case ssaop.OpAMD64VPDPWSSD512:
- return rewriteValueAMD64_OpAMD64VPDPWSSD512(v)
+ return rewriteValue_OpAMD64VPDPWSSD512(v)
case ssaop.OpAMD64VPDPWSSDMasked128:
- return rewriteValueAMD64_OpAMD64VPDPWSSDMasked128(v)
+ return rewriteValue_OpAMD64VPDPWSSDMasked128(v)
case ssaop.OpAMD64VPDPWSSDMasked256:
- return rewriteValueAMD64_OpAMD64VPDPWSSDMasked256(v)
+ return rewriteValue_OpAMD64VPDPWSSDMasked256(v)
case ssaop.OpAMD64VPDPWSSDMasked512:
- return rewriteValueAMD64_OpAMD64VPDPWSSDMasked512(v)
+ return rewriteValue_OpAMD64VPDPWSSDMasked512(v)
case ssaop.OpAMD64VPERM2F128256:
- return rewriteValueAMD64_OpAMD64VPERM2F128256(v)
+ return rewriteValue_OpAMD64VPERM2F128256(v)
case ssaop.OpAMD64VPERM2I128256:
- return rewriteValueAMD64_OpAMD64VPERM2I128256(v)
+ return rewriteValue_OpAMD64VPERM2I128256(v)
case ssaop.OpAMD64VPERMB128:
- return rewriteValueAMD64_OpAMD64VPERMB128(v)
+ return rewriteValue_OpAMD64VPERMB128(v)
case ssaop.OpAMD64VPERMB256:
- return rewriteValueAMD64_OpAMD64VPERMB256(v)
+ return rewriteValue_OpAMD64VPERMB256(v)
case ssaop.OpAMD64VPERMBMasked128:
- return rewriteValueAMD64_OpAMD64VPERMBMasked128(v)
+ return rewriteValue_OpAMD64VPERMBMasked128(v)
case ssaop.OpAMD64VPERMBMasked256:
- return rewriteValueAMD64_OpAMD64VPERMBMasked256(v)
+ return rewriteValue_OpAMD64VPERMBMasked256(v)
case ssaop.OpAMD64VPERMD256:
- return rewriteValueAMD64_OpAMD64VPERMD256(v)
+ return rewriteValue_OpAMD64VPERMD256(v)
case ssaop.OpAMD64VPERMD512:
- return rewriteValueAMD64_OpAMD64VPERMD512(v)
+ return rewriteValue_OpAMD64VPERMD512(v)
case ssaop.OpAMD64VPERMDMasked256:
- return rewriteValueAMD64_OpAMD64VPERMDMasked256(v)
+ return rewriteValue_OpAMD64VPERMDMasked256(v)
case ssaop.OpAMD64VPERMDMasked512:
- return rewriteValueAMD64_OpAMD64VPERMDMasked512(v)
+ return rewriteValue_OpAMD64VPERMDMasked512(v)
case ssaop.OpAMD64VPERMI2B128:
- return rewriteValueAMD64_OpAMD64VPERMI2B128(v)
+ return rewriteValue_OpAMD64VPERMI2B128(v)
case ssaop.OpAMD64VPERMI2B256:
- return rewriteValueAMD64_OpAMD64VPERMI2B256(v)
+ return rewriteValue_OpAMD64VPERMI2B256(v)
case ssaop.OpAMD64VPERMI2BMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2BMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2BMasked128(v)
case ssaop.OpAMD64VPERMI2BMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2BMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2BMasked256(v)
case ssaop.OpAMD64VPERMI2D128:
- return rewriteValueAMD64_OpAMD64VPERMI2D128(v)
+ return rewriteValue_OpAMD64VPERMI2D128(v)
case ssaop.OpAMD64VPERMI2D256:
- return rewriteValueAMD64_OpAMD64VPERMI2D256(v)
+ return rewriteValue_OpAMD64VPERMI2D256(v)
case ssaop.OpAMD64VPERMI2D512:
- return rewriteValueAMD64_OpAMD64VPERMI2D512(v)
+ return rewriteValue_OpAMD64VPERMI2D512(v)
case ssaop.OpAMD64VPERMI2DMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2DMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2DMasked128(v)
case ssaop.OpAMD64VPERMI2DMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2DMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2DMasked256(v)
case ssaop.OpAMD64VPERMI2DMasked512:
- return rewriteValueAMD64_OpAMD64VPERMI2DMasked512(v)
+ return rewriteValue_OpAMD64VPERMI2DMasked512(v)
case ssaop.OpAMD64VPERMI2PD128:
- return rewriteValueAMD64_OpAMD64VPERMI2PD128(v)
+ return rewriteValue_OpAMD64VPERMI2PD128(v)
case ssaop.OpAMD64VPERMI2PD256:
- return rewriteValueAMD64_OpAMD64VPERMI2PD256(v)
+ return rewriteValue_OpAMD64VPERMI2PD256(v)
case ssaop.OpAMD64VPERMI2PD512:
- return rewriteValueAMD64_OpAMD64VPERMI2PD512(v)
+ return rewriteValue_OpAMD64VPERMI2PD512(v)
case ssaop.OpAMD64VPERMI2PDMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2PDMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2PDMasked128(v)
case ssaop.OpAMD64VPERMI2PDMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2PDMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2PDMasked256(v)
case ssaop.OpAMD64VPERMI2PDMasked512:
- return rewriteValueAMD64_OpAMD64VPERMI2PDMasked512(v)
+ return rewriteValue_OpAMD64VPERMI2PDMasked512(v)
case ssaop.OpAMD64VPERMI2PS128:
- return rewriteValueAMD64_OpAMD64VPERMI2PS128(v)
+ return rewriteValue_OpAMD64VPERMI2PS128(v)
case ssaop.OpAMD64VPERMI2PS256:
- return rewriteValueAMD64_OpAMD64VPERMI2PS256(v)
+ return rewriteValue_OpAMD64VPERMI2PS256(v)
case ssaop.OpAMD64VPERMI2PS512:
- return rewriteValueAMD64_OpAMD64VPERMI2PS512(v)
+ return rewriteValue_OpAMD64VPERMI2PS512(v)
case ssaop.OpAMD64VPERMI2PSMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2PSMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2PSMasked128(v)
case ssaop.OpAMD64VPERMI2PSMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2PSMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2PSMasked256(v)
case ssaop.OpAMD64VPERMI2PSMasked512:
- return rewriteValueAMD64_OpAMD64VPERMI2PSMasked512(v)
+ return rewriteValue_OpAMD64VPERMI2PSMasked512(v)
case ssaop.OpAMD64VPERMI2Q128:
- return rewriteValueAMD64_OpAMD64VPERMI2Q128(v)
+ return rewriteValue_OpAMD64VPERMI2Q128(v)
case ssaop.OpAMD64VPERMI2Q256:
- return rewriteValueAMD64_OpAMD64VPERMI2Q256(v)
+ return rewriteValue_OpAMD64VPERMI2Q256(v)
case ssaop.OpAMD64VPERMI2Q512:
- return rewriteValueAMD64_OpAMD64VPERMI2Q512(v)
+ return rewriteValue_OpAMD64VPERMI2Q512(v)
case ssaop.OpAMD64VPERMI2QMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2QMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2QMasked128(v)
case ssaop.OpAMD64VPERMI2QMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2QMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2QMasked256(v)
case ssaop.OpAMD64VPERMI2QMasked512:
- return rewriteValueAMD64_OpAMD64VPERMI2QMasked512(v)
+ return rewriteValue_OpAMD64VPERMI2QMasked512(v)
case ssaop.OpAMD64VPERMI2W128:
- return rewriteValueAMD64_OpAMD64VPERMI2W128(v)
+ return rewriteValue_OpAMD64VPERMI2W128(v)
case ssaop.OpAMD64VPERMI2W256:
- return rewriteValueAMD64_OpAMD64VPERMI2W256(v)
+ return rewriteValue_OpAMD64VPERMI2W256(v)
case ssaop.OpAMD64VPERMI2WMasked128:
- return rewriteValueAMD64_OpAMD64VPERMI2WMasked128(v)
+ return rewriteValue_OpAMD64VPERMI2WMasked128(v)
case ssaop.OpAMD64VPERMI2WMasked256:
- return rewriteValueAMD64_OpAMD64VPERMI2WMasked256(v)
+ return rewriteValue_OpAMD64VPERMI2WMasked256(v)
case ssaop.OpAMD64VPERMPD256:
- return rewriteValueAMD64_OpAMD64VPERMPD256(v)
+ return rewriteValue_OpAMD64VPERMPD256(v)
case ssaop.OpAMD64VPERMPD512:
- return rewriteValueAMD64_OpAMD64VPERMPD512(v)
+ return rewriteValue_OpAMD64VPERMPD512(v)
case ssaop.OpAMD64VPERMPDMasked256:
- return rewriteValueAMD64_OpAMD64VPERMPDMasked256(v)
+ return rewriteValue_OpAMD64VPERMPDMasked256(v)
case ssaop.OpAMD64VPERMPDMasked512:
- return rewriteValueAMD64_OpAMD64VPERMPDMasked512(v)
+ return rewriteValue_OpAMD64VPERMPDMasked512(v)
case ssaop.OpAMD64VPERMPS256:
- return rewriteValueAMD64_OpAMD64VPERMPS256(v)
+ return rewriteValue_OpAMD64VPERMPS256(v)
case ssaop.OpAMD64VPERMPS512:
- return rewriteValueAMD64_OpAMD64VPERMPS512(v)
+ return rewriteValue_OpAMD64VPERMPS512(v)
case ssaop.OpAMD64VPERMPSMasked256:
- return rewriteValueAMD64_OpAMD64VPERMPSMasked256(v)
+ return rewriteValue_OpAMD64VPERMPSMasked256(v)
case ssaop.OpAMD64VPERMPSMasked512:
- return rewriteValueAMD64_OpAMD64VPERMPSMasked512(v)
+ return rewriteValue_OpAMD64VPERMPSMasked512(v)
case ssaop.OpAMD64VPERMQ256:
- return rewriteValueAMD64_OpAMD64VPERMQ256(v)
+ return rewriteValue_OpAMD64VPERMQ256(v)
case ssaop.OpAMD64VPERMQ512:
- return rewriteValueAMD64_OpAMD64VPERMQ512(v)
+ return rewriteValue_OpAMD64VPERMQ512(v)
case ssaop.OpAMD64VPERMQMasked256:
- return rewriteValueAMD64_OpAMD64VPERMQMasked256(v)
+ return rewriteValue_OpAMD64VPERMQMasked256(v)
case ssaop.OpAMD64VPERMQMasked512:
- return rewriteValueAMD64_OpAMD64VPERMQMasked512(v)
+ return rewriteValue_OpAMD64VPERMQMasked512(v)
case ssaop.OpAMD64VPERMW128:
- return rewriteValueAMD64_OpAMD64VPERMW128(v)
+ return rewriteValue_OpAMD64VPERMW128(v)
case ssaop.OpAMD64VPERMW256:
- return rewriteValueAMD64_OpAMD64VPERMW256(v)
+ return rewriteValue_OpAMD64VPERMW256(v)
case ssaop.OpAMD64VPERMWMasked128:
- return rewriteValueAMD64_OpAMD64VPERMWMasked128(v)
+ return rewriteValue_OpAMD64VPERMWMasked128(v)
case ssaop.OpAMD64VPERMWMasked256:
- return rewriteValueAMD64_OpAMD64VPERMWMasked256(v)
+ return rewriteValue_OpAMD64VPERMWMasked256(v)
case ssaop.OpAMD64VPEXPANDBMasked128:
- return rewriteValueAMD64_OpAMD64VPEXPANDBMasked128(v)
+ return rewriteValue_OpAMD64VPEXPANDBMasked128(v)
case ssaop.OpAMD64VPEXPANDBMasked256:
- return rewriteValueAMD64_OpAMD64VPEXPANDBMasked256(v)
+ return rewriteValue_OpAMD64VPEXPANDBMasked256(v)
case ssaop.OpAMD64VPEXPANDDMasked128:
- return rewriteValueAMD64_OpAMD64VPEXPANDDMasked128(v)
+ return rewriteValue_OpAMD64VPEXPANDDMasked128(v)
case ssaop.OpAMD64VPEXPANDDMasked256:
- return rewriteValueAMD64_OpAMD64VPEXPANDDMasked256(v)
+ return rewriteValue_OpAMD64VPEXPANDDMasked256(v)
case ssaop.OpAMD64VPEXPANDQMasked128:
- return rewriteValueAMD64_OpAMD64VPEXPANDQMasked128(v)
+ return rewriteValue_OpAMD64VPEXPANDQMasked128(v)
case ssaop.OpAMD64VPEXPANDQMasked256:
- return rewriteValueAMD64_OpAMD64VPEXPANDQMasked256(v)
+ return rewriteValue_OpAMD64VPEXPANDQMasked256(v)
case ssaop.OpAMD64VPEXPANDWMasked128:
- return rewriteValueAMD64_OpAMD64VPEXPANDWMasked128(v)
+ return rewriteValue_OpAMD64VPEXPANDWMasked128(v)
case ssaop.OpAMD64VPEXPANDWMasked256:
- return rewriteValueAMD64_OpAMD64VPEXPANDWMasked256(v)
+ return rewriteValue_OpAMD64VPEXPANDWMasked256(v)
case ssaop.OpAMD64VPHADDD128:
- return rewriteValueAMD64_OpAMD64VPHADDD128(v)
+ return rewriteValue_OpAMD64VPHADDD128(v)
case ssaop.OpAMD64VPHADDD256:
- return rewriteValueAMD64_OpAMD64VPHADDD256(v)
+ return rewriteValue_OpAMD64VPHADDD256(v)
case ssaop.OpAMD64VPHADDSW128:
- return rewriteValueAMD64_OpAMD64VPHADDSW128(v)
+ return rewriteValue_OpAMD64VPHADDSW128(v)
case ssaop.OpAMD64VPHADDSW256:
- return rewriteValueAMD64_OpAMD64VPHADDSW256(v)
+ return rewriteValue_OpAMD64VPHADDSW256(v)
case ssaop.OpAMD64VPHADDW128:
- return rewriteValueAMD64_OpAMD64VPHADDW128(v)
+ return rewriteValue_OpAMD64VPHADDW128(v)
case ssaop.OpAMD64VPHADDW256:
- return rewriteValueAMD64_OpAMD64VPHADDW256(v)
+ return rewriteValue_OpAMD64VPHADDW256(v)
case ssaop.OpAMD64VPHSUBD128:
- return rewriteValueAMD64_OpAMD64VPHSUBD128(v)
+ return rewriteValue_OpAMD64VPHSUBD128(v)
case ssaop.OpAMD64VPHSUBD256:
- return rewriteValueAMD64_OpAMD64VPHSUBD256(v)
+ return rewriteValue_OpAMD64VPHSUBD256(v)
case ssaop.OpAMD64VPHSUBSW128:
- return rewriteValueAMD64_OpAMD64VPHSUBSW128(v)
+ return rewriteValue_OpAMD64VPHSUBSW128(v)
case ssaop.OpAMD64VPHSUBSW256:
- return rewriteValueAMD64_OpAMD64VPHSUBSW256(v)
+ return rewriteValue_OpAMD64VPHSUBSW256(v)
case ssaop.OpAMD64VPHSUBW128:
- return rewriteValueAMD64_OpAMD64VPHSUBW128(v)
+ return rewriteValue_OpAMD64VPHSUBW128(v)
case ssaop.OpAMD64VPHSUBW256:
- return rewriteValueAMD64_OpAMD64VPHSUBW256(v)
+ return rewriteValue_OpAMD64VPHSUBW256(v)
case ssaop.OpAMD64VPINSRD128:
- return rewriteValueAMD64_OpAMD64VPINSRD128(v)
+ return rewriteValue_OpAMD64VPINSRD128(v)
case ssaop.OpAMD64VPINSRQ128:
- return rewriteValueAMD64_OpAMD64VPINSRQ128(v)
+ return rewriteValue_OpAMD64VPINSRQ128(v)
case ssaop.OpAMD64VPLZCNTD128:
- return rewriteValueAMD64_OpAMD64VPLZCNTD128(v)
+ return rewriteValue_OpAMD64VPLZCNTD128(v)
case ssaop.OpAMD64VPLZCNTD256:
- return rewriteValueAMD64_OpAMD64VPLZCNTD256(v)
+ return rewriteValue_OpAMD64VPLZCNTD256(v)
case ssaop.OpAMD64VPLZCNTD512:
- return rewriteValueAMD64_OpAMD64VPLZCNTD512(v)
+ return rewriteValue_OpAMD64VPLZCNTD512(v)
case ssaop.OpAMD64VPLZCNTDMasked128:
- return rewriteValueAMD64_OpAMD64VPLZCNTDMasked128(v)
+ return rewriteValue_OpAMD64VPLZCNTDMasked128(v)
case ssaop.OpAMD64VPLZCNTDMasked256:
- return rewriteValueAMD64_OpAMD64VPLZCNTDMasked256(v)
+ return rewriteValue_OpAMD64VPLZCNTDMasked256(v)
case ssaop.OpAMD64VPLZCNTDMasked512:
- return rewriteValueAMD64_OpAMD64VPLZCNTDMasked512(v)
+ return rewriteValue_OpAMD64VPLZCNTDMasked512(v)
case ssaop.OpAMD64VPLZCNTQ128:
- return rewriteValueAMD64_OpAMD64VPLZCNTQ128(v)
+ return rewriteValue_OpAMD64VPLZCNTQ128(v)
case ssaop.OpAMD64VPLZCNTQ256:
- return rewriteValueAMD64_OpAMD64VPLZCNTQ256(v)
+ return rewriteValue_OpAMD64VPLZCNTQ256(v)
case ssaop.OpAMD64VPLZCNTQ512:
- return rewriteValueAMD64_OpAMD64VPLZCNTQ512(v)
+ return rewriteValue_OpAMD64VPLZCNTQ512(v)
case ssaop.OpAMD64VPLZCNTQMasked128:
- return rewriteValueAMD64_OpAMD64VPLZCNTQMasked128(v)
+ return rewriteValue_OpAMD64VPLZCNTQMasked128(v)
case ssaop.OpAMD64VPLZCNTQMasked256:
- return rewriteValueAMD64_OpAMD64VPLZCNTQMasked256(v)
+ return rewriteValue_OpAMD64VPLZCNTQMasked256(v)
case ssaop.OpAMD64VPLZCNTQMasked512:
- return rewriteValueAMD64_OpAMD64VPLZCNTQMasked512(v)
+ return rewriteValue_OpAMD64VPLZCNTQMasked512(v)
case ssaop.OpAMD64VPMADDUBSW128:
- return rewriteValueAMD64_OpAMD64VPMADDUBSW128(v)
+ return rewriteValue_OpAMD64VPMADDUBSW128(v)
case ssaop.OpAMD64VPMADDUBSW256:
- return rewriteValueAMD64_OpAMD64VPMADDUBSW256(v)
+ return rewriteValue_OpAMD64VPMADDUBSW256(v)
case ssaop.OpAMD64VPMADDUBSWMasked128:
- return rewriteValueAMD64_OpAMD64VPMADDUBSWMasked128(v)
+ return rewriteValue_OpAMD64VPMADDUBSWMasked128(v)
case ssaop.OpAMD64VPMADDUBSWMasked256:
- return rewriteValueAMD64_OpAMD64VPMADDUBSWMasked256(v)
+ return rewriteValue_OpAMD64VPMADDUBSWMasked256(v)
case ssaop.OpAMD64VPMADDWD128:
- return rewriteValueAMD64_OpAMD64VPMADDWD128(v)
+ return rewriteValue_OpAMD64VPMADDWD128(v)
case ssaop.OpAMD64VPMADDWD256:
- return rewriteValueAMD64_OpAMD64VPMADDWD256(v)
+ return rewriteValue_OpAMD64VPMADDWD256(v)
case ssaop.OpAMD64VPMADDWDMasked128:
- return rewriteValueAMD64_OpAMD64VPMADDWDMasked128(v)
+ return rewriteValue_OpAMD64VPMADDWDMasked128(v)
case ssaop.OpAMD64VPMADDWDMasked256:
- return rewriteValueAMD64_OpAMD64VPMADDWDMasked256(v)
+ return rewriteValue_OpAMD64VPMADDWDMasked256(v)
case ssaop.OpAMD64VPMAXSB128:
- return rewriteValueAMD64_OpAMD64VPMAXSB128(v)
+ return rewriteValue_OpAMD64VPMAXSB128(v)
case ssaop.OpAMD64VPMAXSB256:
- return rewriteValueAMD64_OpAMD64VPMAXSB256(v)
+ return rewriteValue_OpAMD64VPMAXSB256(v)
case ssaop.OpAMD64VPMAXSBMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXSBMasked128(v)
+ return rewriteValue_OpAMD64VPMAXSBMasked128(v)
case ssaop.OpAMD64VPMAXSBMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXSBMasked256(v)
+ return rewriteValue_OpAMD64VPMAXSBMasked256(v)
case ssaop.OpAMD64VPMAXSD128:
- return rewriteValueAMD64_OpAMD64VPMAXSD128(v)
+ return rewriteValue_OpAMD64VPMAXSD128(v)
case ssaop.OpAMD64VPMAXSD256:
- return rewriteValueAMD64_OpAMD64VPMAXSD256(v)
+ return rewriteValue_OpAMD64VPMAXSD256(v)
case ssaop.OpAMD64VPMAXSD512:
- return rewriteValueAMD64_OpAMD64VPMAXSD512(v)
+ return rewriteValue_OpAMD64VPMAXSD512(v)
case ssaop.OpAMD64VPMAXSDMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXSDMasked128(v)
+ return rewriteValue_OpAMD64VPMAXSDMasked128(v)
case ssaop.OpAMD64VPMAXSDMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXSDMasked256(v)
+ return rewriteValue_OpAMD64VPMAXSDMasked256(v)
case ssaop.OpAMD64VPMAXSDMasked512:
- return rewriteValueAMD64_OpAMD64VPMAXSDMasked512(v)
+ return rewriteValue_OpAMD64VPMAXSDMasked512(v)
case ssaop.OpAMD64VPMAXSQ128:
- return rewriteValueAMD64_OpAMD64VPMAXSQ128(v)
+ return rewriteValue_OpAMD64VPMAXSQ128(v)
case ssaop.OpAMD64VPMAXSQ256:
- return rewriteValueAMD64_OpAMD64VPMAXSQ256(v)
+ return rewriteValue_OpAMD64VPMAXSQ256(v)
case ssaop.OpAMD64VPMAXSQ512:
- return rewriteValueAMD64_OpAMD64VPMAXSQ512(v)
+ return rewriteValue_OpAMD64VPMAXSQ512(v)
case ssaop.OpAMD64VPMAXSQMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXSQMasked128(v)
+ return rewriteValue_OpAMD64VPMAXSQMasked128(v)
case ssaop.OpAMD64VPMAXSQMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXSQMasked256(v)
+ return rewriteValue_OpAMD64VPMAXSQMasked256(v)
case ssaop.OpAMD64VPMAXSQMasked512:
- return rewriteValueAMD64_OpAMD64VPMAXSQMasked512(v)
+ return rewriteValue_OpAMD64VPMAXSQMasked512(v)
case ssaop.OpAMD64VPMAXSW128:
- return rewriteValueAMD64_OpAMD64VPMAXSW128(v)
+ return rewriteValue_OpAMD64VPMAXSW128(v)
case ssaop.OpAMD64VPMAXSW256:
- return rewriteValueAMD64_OpAMD64VPMAXSW256(v)
+ return rewriteValue_OpAMD64VPMAXSW256(v)
case ssaop.OpAMD64VPMAXSWMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXSWMasked128(v)
+ return rewriteValue_OpAMD64VPMAXSWMasked128(v)
case ssaop.OpAMD64VPMAXSWMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXSWMasked256(v)
+ return rewriteValue_OpAMD64VPMAXSWMasked256(v)
case ssaop.OpAMD64VPMAXUB128:
- return rewriteValueAMD64_OpAMD64VPMAXUB128(v)
+ return rewriteValue_OpAMD64VPMAXUB128(v)
case ssaop.OpAMD64VPMAXUB256:
- return rewriteValueAMD64_OpAMD64VPMAXUB256(v)
+ return rewriteValue_OpAMD64VPMAXUB256(v)
case ssaop.OpAMD64VPMAXUBMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXUBMasked128(v)
+ return rewriteValue_OpAMD64VPMAXUBMasked128(v)
case ssaop.OpAMD64VPMAXUBMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXUBMasked256(v)
+ return rewriteValue_OpAMD64VPMAXUBMasked256(v)
case ssaop.OpAMD64VPMAXUD128:
- return rewriteValueAMD64_OpAMD64VPMAXUD128(v)
+ return rewriteValue_OpAMD64VPMAXUD128(v)
case ssaop.OpAMD64VPMAXUD256:
- return rewriteValueAMD64_OpAMD64VPMAXUD256(v)
+ return rewriteValue_OpAMD64VPMAXUD256(v)
case ssaop.OpAMD64VPMAXUD512:
- return rewriteValueAMD64_OpAMD64VPMAXUD512(v)
+ return rewriteValue_OpAMD64VPMAXUD512(v)
case ssaop.OpAMD64VPMAXUDMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXUDMasked128(v)
+ return rewriteValue_OpAMD64VPMAXUDMasked128(v)
case ssaop.OpAMD64VPMAXUDMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXUDMasked256(v)
+ return rewriteValue_OpAMD64VPMAXUDMasked256(v)
case ssaop.OpAMD64VPMAXUDMasked512:
- return rewriteValueAMD64_OpAMD64VPMAXUDMasked512(v)
+ return rewriteValue_OpAMD64VPMAXUDMasked512(v)
case ssaop.OpAMD64VPMAXUQ128:
- return rewriteValueAMD64_OpAMD64VPMAXUQ128(v)
+ return rewriteValue_OpAMD64VPMAXUQ128(v)
case ssaop.OpAMD64VPMAXUQ256:
- return rewriteValueAMD64_OpAMD64VPMAXUQ256(v)
+ return rewriteValue_OpAMD64VPMAXUQ256(v)
case ssaop.OpAMD64VPMAXUQ512:
- return rewriteValueAMD64_OpAMD64VPMAXUQ512(v)
+ return rewriteValue_OpAMD64VPMAXUQ512(v)
case ssaop.OpAMD64VPMAXUQMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXUQMasked128(v)
+ return rewriteValue_OpAMD64VPMAXUQMasked128(v)
case ssaop.OpAMD64VPMAXUQMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXUQMasked256(v)
+ return rewriteValue_OpAMD64VPMAXUQMasked256(v)
case ssaop.OpAMD64VPMAXUQMasked512:
- return rewriteValueAMD64_OpAMD64VPMAXUQMasked512(v)
+ return rewriteValue_OpAMD64VPMAXUQMasked512(v)
case ssaop.OpAMD64VPMAXUW128:
- return rewriteValueAMD64_OpAMD64VPMAXUW128(v)
+ return rewriteValue_OpAMD64VPMAXUW128(v)
case ssaop.OpAMD64VPMAXUW256:
- return rewriteValueAMD64_OpAMD64VPMAXUW256(v)
+ return rewriteValue_OpAMD64VPMAXUW256(v)
case ssaop.OpAMD64VPMAXUWMasked128:
- return rewriteValueAMD64_OpAMD64VPMAXUWMasked128(v)
+ return rewriteValue_OpAMD64VPMAXUWMasked128(v)
case ssaop.OpAMD64VPMAXUWMasked256:
- return rewriteValueAMD64_OpAMD64VPMAXUWMasked256(v)
+ return rewriteValue_OpAMD64VPMAXUWMasked256(v)
case ssaop.OpAMD64VPMINSB128:
- return rewriteValueAMD64_OpAMD64VPMINSB128(v)
+ return rewriteValue_OpAMD64VPMINSB128(v)
case ssaop.OpAMD64VPMINSB256:
- return rewriteValueAMD64_OpAMD64VPMINSB256(v)
+ return rewriteValue_OpAMD64VPMINSB256(v)
case ssaop.OpAMD64VPMINSBMasked128:
- return rewriteValueAMD64_OpAMD64VPMINSBMasked128(v)
+ return rewriteValue_OpAMD64VPMINSBMasked128(v)
case ssaop.OpAMD64VPMINSBMasked256:
- return rewriteValueAMD64_OpAMD64VPMINSBMasked256(v)
+ return rewriteValue_OpAMD64VPMINSBMasked256(v)
case ssaop.OpAMD64VPMINSD128:
- return rewriteValueAMD64_OpAMD64VPMINSD128(v)
+ return rewriteValue_OpAMD64VPMINSD128(v)
case ssaop.OpAMD64VPMINSD256:
- return rewriteValueAMD64_OpAMD64VPMINSD256(v)
+ return rewriteValue_OpAMD64VPMINSD256(v)
case ssaop.OpAMD64VPMINSD512:
- return rewriteValueAMD64_OpAMD64VPMINSD512(v)
+ return rewriteValue_OpAMD64VPMINSD512(v)
case ssaop.OpAMD64VPMINSDMasked128:
- return rewriteValueAMD64_OpAMD64VPMINSDMasked128(v)
+ return rewriteValue_OpAMD64VPMINSDMasked128(v)
case ssaop.OpAMD64VPMINSDMasked256:
- return rewriteValueAMD64_OpAMD64VPMINSDMasked256(v)
+ return rewriteValue_OpAMD64VPMINSDMasked256(v)
case ssaop.OpAMD64VPMINSDMasked512:
- return rewriteValueAMD64_OpAMD64VPMINSDMasked512(v)
+ return rewriteValue_OpAMD64VPMINSDMasked512(v)
case ssaop.OpAMD64VPMINSQ128:
- return rewriteValueAMD64_OpAMD64VPMINSQ128(v)
+ return rewriteValue_OpAMD64VPMINSQ128(v)
case ssaop.OpAMD64VPMINSQ256:
- return rewriteValueAMD64_OpAMD64VPMINSQ256(v)
+ return rewriteValue_OpAMD64VPMINSQ256(v)
case ssaop.OpAMD64VPMINSQ512:
- return rewriteValueAMD64_OpAMD64VPMINSQ512(v)
+ return rewriteValue_OpAMD64VPMINSQ512(v)
case ssaop.OpAMD64VPMINSQMasked128:
- return rewriteValueAMD64_OpAMD64VPMINSQMasked128(v)
+ return rewriteValue_OpAMD64VPMINSQMasked128(v)
case ssaop.OpAMD64VPMINSQMasked256:
- return rewriteValueAMD64_OpAMD64VPMINSQMasked256(v)
+ return rewriteValue_OpAMD64VPMINSQMasked256(v)
case ssaop.OpAMD64VPMINSQMasked512:
- return rewriteValueAMD64_OpAMD64VPMINSQMasked512(v)
+ return rewriteValue_OpAMD64VPMINSQMasked512(v)
case ssaop.OpAMD64VPMINSW128:
- return rewriteValueAMD64_OpAMD64VPMINSW128(v)
+ return rewriteValue_OpAMD64VPMINSW128(v)
case ssaop.OpAMD64VPMINSW256:
- return rewriteValueAMD64_OpAMD64VPMINSW256(v)
+ return rewriteValue_OpAMD64VPMINSW256(v)
case ssaop.OpAMD64VPMINSWMasked128:
- return rewriteValueAMD64_OpAMD64VPMINSWMasked128(v)
+ return rewriteValue_OpAMD64VPMINSWMasked128(v)
case ssaop.OpAMD64VPMINSWMasked256:
- return rewriteValueAMD64_OpAMD64VPMINSWMasked256(v)
+ return rewriteValue_OpAMD64VPMINSWMasked256(v)
case ssaop.OpAMD64VPMINUB128:
- return rewriteValueAMD64_OpAMD64VPMINUB128(v)
+ return rewriteValue_OpAMD64VPMINUB128(v)
case ssaop.OpAMD64VPMINUB256:
- return rewriteValueAMD64_OpAMD64VPMINUB256(v)
+ return rewriteValue_OpAMD64VPMINUB256(v)
case ssaop.OpAMD64VPMINUBMasked128:
- return rewriteValueAMD64_OpAMD64VPMINUBMasked128(v)
+ return rewriteValue_OpAMD64VPMINUBMasked128(v)
case ssaop.OpAMD64VPMINUBMasked256:
- return rewriteValueAMD64_OpAMD64VPMINUBMasked256(v)
+ return rewriteValue_OpAMD64VPMINUBMasked256(v)
case ssaop.OpAMD64VPMINUD128:
- return rewriteValueAMD64_OpAMD64VPMINUD128(v)
+ return rewriteValue_OpAMD64VPMINUD128(v)
case ssaop.OpAMD64VPMINUD256:
- return rewriteValueAMD64_OpAMD64VPMINUD256(v)
+ return rewriteValue_OpAMD64VPMINUD256(v)
case ssaop.OpAMD64VPMINUD512:
- return rewriteValueAMD64_OpAMD64VPMINUD512(v)
+ return rewriteValue_OpAMD64VPMINUD512(v)
case ssaop.OpAMD64VPMINUDMasked128:
- return rewriteValueAMD64_OpAMD64VPMINUDMasked128(v)
+ return rewriteValue_OpAMD64VPMINUDMasked128(v)
case ssaop.OpAMD64VPMINUDMasked256:
- return rewriteValueAMD64_OpAMD64VPMINUDMasked256(v)
+ return rewriteValue_OpAMD64VPMINUDMasked256(v)
case ssaop.OpAMD64VPMINUDMasked512:
- return rewriteValueAMD64_OpAMD64VPMINUDMasked512(v)
+ return rewriteValue_OpAMD64VPMINUDMasked512(v)
case ssaop.OpAMD64VPMINUQ128:
- return rewriteValueAMD64_OpAMD64VPMINUQ128(v)
+ return rewriteValue_OpAMD64VPMINUQ128(v)
case ssaop.OpAMD64VPMINUQ256:
- return rewriteValueAMD64_OpAMD64VPMINUQ256(v)
+ return rewriteValue_OpAMD64VPMINUQ256(v)
case ssaop.OpAMD64VPMINUQ512:
- return rewriteValueAMD64_OpAMD64VPMINUQ512(v)
+ return rewriteValue_OpAMD64VPMINUQ512(v)
case ssaop.OpAMD64VPMINUQMasked128:
- return rewriteValueAMD64_OpAMD64VPMINUQMasked128(v)
+ return rewriteValue_OpAMD64VPMINUQMasked128(v)
case ssaop.OpAMD64VPMINUQMasked256:
- return rewriteValueAMD64_OpAMD64VPMINUQMasked256(v)
+ return rewriteValue_OpAMD64VPMINUQMasked256(v)
case ssaop.OpAMD64VPMINUQMasked512:
- return rewriteValueAMD64_OpAMD64VPMINUQMasked512(v)
+ return rewriteValue_OpAMD64VPMINUQMasked512(v)
case ssaop.OpAMD64VPMINUW128:
- return rewriteValueAMD64_OpAMD64VPMINUW128(v)
+ return rewriteValue_OpAMD64VPMINUW128(v)
case ssaop.OpAMD64VPMINUW256:
- return rewriteValueAMD64_OpAMD64VPMINUW256(v)
+ return rewriteValue_OpAMD64VPMINUW256(v)
case ssaop.OpAMD64VPMINUWMasked128:
- return rewriteValueAMD64_OpAMD64VPMINUWMasked128(v)
+ return rewriteValue_OpAMD64VPMINUWMasked128(v)
case ssaop.OpAMD64VPMINUWMasked256:
- return rewriteValueAMD64_OpAMD64VPMINUWMasked256(v)
+ return rewriteValue_OpAMD64VPMINUWMasked256(v)
case ssaop.OpAMD64VPMOVSXBD128:
- return rewriteValueAMD64_OpAMD64VPMOVSXBD128(v)
+ return rewriteValue_OpAMD64VPMOVSXBD128(v)
case ssaop.OpAMD64VPMOVSXBD256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBD256(v)
+ return rewriteValue_OpAMD64VPMOVSXBD256(v)
case ssaop.OpAMD64VPMOVSXBD512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBD512(v)
+ return rewriteValue_OpAMD64VPMOVSXBD512(v)
case ssaop.OpAMD64VPMOVSXBDMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVSXBDMasked128(v)
+ return rewriteValue_OpAMD64VPMOVSXBDMasked128(v)
case ssaop.OpAMD64VPMOVSXBDMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBDMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXBDMasked256(v)
case ssaop.OpAMD64VPMOVSXBDMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBDMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXBDMasked512(v)
case ssaop.OpAMD64VPMOVSXBQ128:
- return rewriteValueAMD64_OpAMD64VPMOVSXBQ128(v)
+ return rewriteValue_OpAMD64VPMOVSXBQ128(v)
case ssaop.OpAMD64VPMOVSXBQ256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBQ256(v)
+ return rewriteValue_OpAMD64VPMOVSXBQ256(v)
case ssaop.OpAMD64VPMOVSXBQ512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBQ512(v)
+ return rewriteValue_OpAMD64VPMOVSXBQ512(v)
case ssaop.OpAMD64VPMOVSXBQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXBQMasked256(v)
case ssaop.OpAMD64VPMOVSXBQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXBQMasked512(v)
case ssaop.OpAMD64VPMOVSXBW128:
- return rewriteValueAMD64_OpAMD64VPMOVSXBW128(v)
+ return rewriteValue_OpAMD64VPMOVSXBW128(v)
case ssaop.OpAMD64VPMOVSXBW256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBW256(v)
+ return rewriteValue_OpAMD64VPMOVSXBW256(v)
case ssaop.OpAMD64VPMOVSXBW512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBW512(v)
+ return rewriteValue_OpAMD64VPMOVSXBW512(v)
case ssaop.OpAMD64VPMOVSXBWMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVSXBWMasked128(v)
+ return rewriteValue_OpAMD64VPMOVSXBWMasked128(v)
case ssaop.OpAMD64VPMOVSXBWMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXBWMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXBWMasked256(v)
case ssaop.OpAMD64VPMOVSXBWMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXBWMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXBWMasked512(v)
case ssaop.OpAMD64VPMOVSXDQ128:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQ128(v)
+ return rewriteValue_OpAMD64VPMOVSXDQ128(v)
case ssaop.OpAMD64VPMOVSXDQ256:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQ256(v)
+ return rewriteValue_OpAMD64VPMOVSXDQ256(v)
case ssaop.OpAMD64VPMOVSXDQ512:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQ512(v)
+ return rewriteValue_OpAMD64VPMOVSXDQ512(v)
case ssaop.OpAMD64VPMOVSXDQMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQMasked128(v)
+ return rewriteValue_OpAMD64VPMOVSXDQMasked128(v)
case ssaop.OpAMD64VPMOVSXDQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXDQMasked256(v)
case ssaop.OpAMD64VPMOVSXDQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXDQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXDQMasked512(v)
case ssaop.OpAMD64VPMOVSXWD128:
- return rewriteValueAMD64_OpAMD64VPMOVSXWD128(v)
+ return rewriteValue_OpAMD64VPMOVSXWD128(v)
case ssaop.OpAMD64VPMOVSXWD256:
- return rewriteValueAMD64_OpAMD64VPMOVSXWD256(v)
+ return rewriteValue_OpAMD64VPMOVSXWD256(v)
case ssaop.OpAMD64VPMOVSXWD512:
- return rewriteValueAMD64_OpAMD64VPMOVSXWD512(v)
+ return rewriteValue_OpAMD64VPMOVSXWD512(v)
case ssaop.OpAMD64VPMOVSXWDMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVSXWDMasked128(v)
+ return rewriteValue_OpAMD64VPMOVSXWDMasked128(v)
case ssaop.OpAMD64VPMOVSXWDMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXWDMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXWDMasked256(v)
case ssaop.OpAMD64VPMOVSXWDMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXWDMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXWDMasked512(v)
case ssaop.OpAMD64VPMOVSXWQ128:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQ128(v)
+ return rewriteValue_OpAMD64VPMOVSXWQ128(v)
case ssaop.OpAMD64VPMOVSXWQ256:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQ256(v)
+ return rewriteValue_OpAMD64VPMOVSXWQ256(v)
case ssaop.OpAMD64VPMOVSXWQ512:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQ512(v)
+ return rewriteValue_OpAMD64VPMOVSXWQ512(v)
case ssaop.OpAMD64VPMOVSXWQMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQMasked128(v)
+ return rewriteValue_OpAMD64VPMOVSXWQMasked128(v)
case ssaop.OpAMD64VPMOVSXWQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVSXWQMasked256(v)
case ssaop.OpAMD64VPMOVSXWQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVSXWQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVSXWQMasked512(v)
case ssaop.OpAMD64VPMOVVec16x16ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec16x16ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec16x16ToM(v)
case ssaop.OpAMD64VPMOVVec16x32ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec16x32ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec16x32ToM(v)
case ssaop.OpAMD64VPMOVVec16x8ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec16x8ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec16x8ToM(v)
case ssaop.OpAMD64VPMOVVec32x16ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec32x16ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec32x16ToM(v)
case ssaop.OpAMD64VPMOVVec32x4ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec32x4ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec32x4ToM(v)
case ssaop.OpAMD64VPMOVVec32x8ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec32x8ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec32x8ToM(v)
case ssaop.OpAMD64VPMOVVec64x2ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec64x2ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec64x2ToM(v)
case ssaop.OpAMD64VPMOVVec64x4ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec64x4ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec64x4ToM(v)
case ssaop.OpAMD64VPMOVVec64x8ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec64x8ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec64x8ToM(v)
case ssaop.OpAMD64VPMOVVec8x16ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec8x16ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec8x16ToM(v)
case ssaop.OpAMD64VPMOVVec8x32ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec8x32ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec8x32ToM(v)
case ssaop.OpAMD64VPMOVVec8x64ToM:
- return rewriteValueAMD64_OpAMD64VPMOVVec8x64ToM(v)
+ return rewriteValue_OpAMD64VPMOVVec8x64ToM(v)
case ssaop.OpAMD64VPMOVZXBD128:
- return rewriteValueAMD64_OpAMD64VPMOVZXBD128(v)
+ return rewriteValue_OpAMD64VPMOVZXBD128(v)
case ssaop.OpAMD64VPMOVZXBD256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBD256(v)
+ return rewriteValue_OpAMD64VPMOVZXBD256(v)
case ssaop.OpAMD64VPMOVZXBD512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBD512(v)
+ return rewriteValue_OpAMD64VPMOVZXBD512(v)
case ssaop.OpAMD64VPMOVZXBDMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVZXBDMasked128(v)
+ return rewriteValue_OpAMD64VPMOVZXBDMasked128(v)
case ssaop.OpAMD64VPMOVZXBDMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBDMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXBDMasked256(v)
case ssaop.OpAMD64VPMOVZXBDMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBDMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXBDMasked512(v)
case ssaop.OpAMD64VPMOVZXBQ128:
- return rewriteValueAMD64_OpAMD64VPMOVZXBQ128(v)
+ return rewriteValue_OpAMD64VPMOVZXBQ128(v)
case ssaop.OpAMD64VPMOVZXBQ256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBQ256(v)
+ return rewriteValue_OpAMD64VPMOVZXBQ256(v)
case ssaop.OpAMD64VPMOVZXBQ512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBQ512(v)
+ return rewriteValue_OpAMD64VPMOVZXBQ512(v)
case ssaop.OpAMD64VPMOVZXBQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXBQMasked256(v)
case ssaop.OpAMD64VPMOVZXBQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXBQMasked512(v)
case ssaop.OpAMD64VPMOVZXBW128:
- return rewriteValueAMD64_OpAMD64VPMOVZXBW128(v)
+ return rewriteValue_OpAMD64VPMOVZXBW128(v)
case ssaop.OpAMD64VPMOVZXBW256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBW256(v)
+ return rewriteValue_OpAMD64VPMOVZXBW256(v)
case ssaop.OpAMD64VPMOVZXBW512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBW512(v)
+ return rewriteValue_OpAMD64VPMOVZXBW512(v)
case ssaop.OpAMD64VPMOVZXBWMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVZXBWMasked128(v)
+ return rewriteValue_OpAMD64VPMOVZXBWMasked128(v)
case ssaop.OpAMD64VPMOVZXBWMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXBWMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXBWMasked256(v)
case ssaop.OpAMD64VPMOVZXBWMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXBWMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXBWMasked512(v)
case ssaop.OpAMD64VPMOVZXDQ128:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQ128(v)
+ return rewriteValue_OpAMD64VPMOVZXDQ128(v)
case ssaop.OpAMD64VPMOVZXDQ256:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQ256(v)
+ return rewriteValue_OpAMD64VPMOVZXDQ256(v)
case ssaop.OpAMD64VPMOVZXDQ512:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQ512(v)
+ return rewriteValue_OpAMD64VPMOVZXDQ512(v)
case ssaop.OpAMD64VPMOVZXDQMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQMasked128(v)
+ return rewriteValue_OpAMD64VPMOVZXDQMasked128(v)
case ssaop.OpAMD64VPMOVZXDQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXDQMasked256(v)
case ssaop.OpAMD64VPMOVZXDQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXDQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXDQMasked512(v)
case ssaop.OpAMD64VPMOVZXWD128:
- return rewriteValueAMD64_OpAMD64VPMOVZXWD128(v)
+ return rewriteValue_OpAMD64VPMOVZXWD128(v)
case ssaop.OpAMD64VPMOVZXWD256:
- return rewriteValueAMD64_OpAMD64VPMOVZXWD256(v)
+ return rewriteValue_OpAMD64VPMOVZXWD256(v)
case ssaop.OpAMD64VPMOVZXWD512:
- return rewriteValueAMD64_OpAMD64VPMOVZXWD512(v)
+ return rewriteValue_OpAMD64VPMOVZXWD512(v)
case ssaop.OpAMD64VPMOVZXWDMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVZXWDMasked128(v)
+ return rewriteValue_OpAMD64VPMOVZXWDMasked128(v)
case ssaop.OpAMD64VPMOVZXWDMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXWDMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXWDMasked256(v)
case ssaop.OpAMD64VPMOVZXWDMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXWDMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXWDMasked512(v)
case ssaop.OpAMD64VPMOVZXWQ128:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQ128(v)
+ return rewriteValue_OpAMD64VPMOVZXWQ128(v)
case ssaop.OpAMD64VPMOVZXWQ256:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQ256(v)
+ return rewriteValue_OpAMD64VPMOVZXWQ256(v)
case ssaop.OpAMD64VPMOVZXWQ512:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQ512(v)
+ return rewriteValue_OpAMD64VPMOVZXWQ512(v)
case ssaop.OpAMD64VPMOVZXWQMasked128:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQMasked128(v)
+ return rewriteValue_OpAMD64VPMOVZXWQMasked128(v)
case ssaop.OpAMD64VPMOVZXWQMasked256:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQMasked256(v)
+ return rewriteValue_OpAMD64VPMOVZXWQMasked256(v)
case ssaop.OpAMD64VPMOVZXWQMasked512:
- return rewriteValueAMD64_OpAMD64VPMOVZXWQMasked512(v)
+ return rewriteValue_OpAMD64VPMOVZXWQMasked512(v)
case ssaop.OpAMD64VPMULDQ128:
- return rewriteValueAMD64_OpAMD64VPMULDQ128(v)
+ return rewriteValue_OpAMD64VPMULDQ128(v)
case ssaop.OpAMD64VPMULDQ256:
- return rewriteValueAMD64_OpAMD64VPMULDQ256(v)
+ return rewriteValue_OpAMD64VPMULDQ256(v)
case ssaop.OpAMD64VPMULHUW128:
- return rewriteValueAMD64_OpAMD64VPMULHUW128(v)
+ return rewriteValue_OpAMD64VPMULHUW128(v)
case ssaop.OpAMD64VPMULHUW256:
- return rewriteValueAMD64_OpAMD64VPMULHUW256(v)
+ return rewriteValue_OpAMD64VPMULHUW256(v)
case ssaop.OpAMD64VPMULHUWMasked128:
- return rewriteValueAMD64_OpAMD64VPMULHUWMasked128(v)
+ return rewriteValue_OpAMD64VPMULHUWMasked128(v)
case ssaop.OpAMD64VPMULHUWMasked256:
- return rewriteValueAMD64_OpAMD64VPMULHUWMasked256(v)
+ return rewriteValue_OpAMD64VPMULHUWMasked256(v)
case ssaop.OpAMD64VPMULHW128:
- return rewriteValueAMD64_OpAMD64VPMULHW128(v)
+ return rewriteValue_OpAMD64VPMULHW128(v)
case ssaop.OpAMD64VPMULHW256:
- return rewriteValueAMD64_OpAMD64VPMULHW256(v)
+ return rewriteValue_OpAMD64VPMULHW256(v)
case ssaop.OpAMD64VPMULHWMasked128:
- return rewriteValueAMD64_OpAMD64VPMULHWMasked128(v)
+ return rewriteValue_OpAMD64VPMULHWMasked128(v)
case ssaop.OpAMD64VPMULHWMasked256:
- return rewriteValueAMD64_OpAMD64VPMULHWMasked256(v)
+ return rewriteValue_OpAMD64VPMULHWMasked256(v)
case ssaop.OpAMD64VPMULLD128:
- return rewriteValueAMD64_OpAMD64VPMULLD128(v)
+ return rewriteValue_OpAMD64VPMULLD128(v)
case ssaop.OpAMD64VPMULLD256:
- return rewriteValueAMD64_OpAMD64VPMULLD256(v)
+ return rewriteValue_OpAMD64VPMULLD256(v)
case ssaop.OpAMD64VPMULLD512:
- return rewriteValueAMD64_OpAMD64VPMULLD512(v)
+ return rewriteValue_OpAMD64VPMULLD512(v)
case ssaop.OpAMD64VPMULLDMasked128:
- return rewriteValueAMD64_OpAMD64VPMULLDMasked128(v)
+ return rewriteValue_OpAMD64VPMULLDMasked128(v)
case ssaop.OpAMD64VPMULLDMasked256:
- return rewriteValueAMD64_OpAMD64VPMULLDMasked256(v)
+ return rewriteValue_OpAMD64VPMULLDMasked256(v)
case ssaop.OpAMD64VPMULLDMasked512:
- return rewriteValueAMD64_OpAMD64VPMULLDMasked512(v)
+ return rewriteValue_OpAMD64VPMULLDMasked512(v)
case ssaop.OpAMD64VPMULLQ128:
- return rewriteValueAMD64_OpAMD64VPMULLQ128(v)
+ return rewriteValue_OpAMD64VPMULLQ128(v)
case ssaop.OpAMD64VPMULLQ256:
- return rewriteValueAMD64_OpAMD64VPMULLQ256(v)
+ return rewriteValue_OpAMD64VPMULLQ256(v)
case ssaop.OpAMD64VPMULLQ512:
- return rewriteValueAMD64_OpAMD64VPMULLQ512(v)
+ return rewriteValue_OpAMD64VPMULLQ512(v)
case ssaop.OpAMD64VPMULLQMasked128:
- return rewriteValueAMD64_OpAMD64VPMULLQMasked128(v)
+ return rewriteValue_OpAMD64VPMULLQMasked128(v)
case ssaop.OpAMD64VPMULLQMasked256:
- return rewriteValueAMD64_OpAMD64VPMULLQMasked256(v)
+ return rewriteValue_OpAMD64VPMULLQMasked256(v)
case ssaop.OpAMD64VPMULLQMasked512:
- return rewriteValueAMD64_OpAMD64VPMULLQMasked512(v)
+ return rewriteValue_OpAMD64VPMULLQMasked512(v)
case ssaop.OpAMD64VPMULLW128:
- return rewriteValueAMD64_OpAMD64VPMULLW128(v)
+ return rewriteValue_OpAMD64VPMULLW128(v)
case ssaop.OpAMD64VPMULLW256:
- return rewriteValueAMD64_OpAMD64VPMULLW256(v)
+ return rewriteValue_OpAMD64VPMULLW256(v)
case ssaop.OpAMD64VPMULLW512:
- return rewriteValueAMD64_OpAMD64VPMULLW512(v)
+ return rewriteValue_OpAMD64VPMULLW512(v)
case ssaop.OpAMD64VPMULLWMasked128:
- return rewriteValueAMD64_OpAMD64VPMULLWMasked128(v)
+ return rewriteValue_OpAMD64VPMULLWMasked128(v)
case ssaop.OpAMD64VPMULLWMasked256:
- return rewriteValueAMD64_OpAMD64VPMULLWMasked256(v)
+ return rewriteValue_OpAMD64VPMULLWMasked256(v)
case ssaop.OpAMD64VPMULUDQ128:
- return rewriteValueAMD64_OpAMD64VPMULUDQ128(v)
+ return rewriteValue_OpAMD64VPMULUDQ128(v)
case ssaop.OpAMD64VPMULUDQ256:
- return rewriteValueAMD64_OpAMD64VPMULUDQ256(v)
+ return rewriteValue_OpAMD64VPMULUDQ256(v)
case ssaop.OpAMD64VPOPCNTB128:
- return rewriteValueAMD64_OpAMD64VPOPCNTB128(v)
+ return rewriteValue_OpAMD64VPOPCNTB128(v)
case ssaop.OpAMD64VPOPCNTB256:
- return rewriteValueAMD64_OpAMD64VPOPCNTB256(v)
+ return rewriteValue_OpAMD64VPOPCNTB256(v)
case ssaop.OpAMD64VPOPCNTBMasked128:
- return rewriteValueAMD64_OpAMD64VPOPCNTBMasked128(v)
+ return rewriteValue_OpAMD64VPOPCNTBMasked128(v)
case ssaop.OpAMD64VPOPCNTBMasked256:
- return rewriteValueAMD64_OpAMD64VPOPCNTBMasked256(v)
+ return rewriteValue_OpAMD64VPOPCNTBMasked256(v)
case ssaop.OpAMD64VPOPCNTD128:
- return rewriteValueAMD64_OpAMD64VPOPCNTD128(v)
+ return rewriteValue_OpAMD64VPOPCNTD128(v)
case ssaop.OpAMD64VPOPCNTD256:
- return rewriteValueAMD64_OpAMD64VPOPCNTD256(v)
+ return rewriteValue_OpAMD64VPOPCNTD256(v)
case ssaop.OpAMD64VPOPCNTD512:
- return rewriteValueAMD64_OpAMD64VPOPCNTD512(v)
+ return rewriteValue_OpAMD64VPOPCNTD512(v)
case ssaop.OpAMD64VPOPCNTDMasked128:
- return rewriteValueAMD64_OpAMD64VPOPCNTDMasked128(v)
+ return rewriteValue_OpAMD64VPOPCNTDMasked128(v)
case ssaop.OpAMD64VPOPCNTDMasked256:
- return rewriteValueAMD64_OpAMD64VPOPCNTDMasked256(v)
+ return rewriteValue_OpAMD64VPOPCNTDMasked256(v)
case ssaop.OpAMD64VPOPCNTDMasked512:
- return rewriteValueAMD64_OpAMD64VPOPCNTDMasked512(v)
+ return rewriteValue_OpAMD64VPOPCNTDMasked512(v)
case ssaop.OpAMD64VPOPCNTQ128:
- return rewriteValueAMD64_OpAMD64VPOPCNTQ128(v)
+ return rewriteValue_OpAMD64VPOPCNTQ128(v)
case ssaop.OpAMD64VPOPCNTQ256:
- return rewriteValueAMD64_OpAMD64VPOPCNTQ256(v)
+ return rewriteValue_OpAMD64VPOPCNTQ256(v)
case ssaop.OpAMD64VPOPCNTQ512:
- return rewriteValueAMD64_OpAMD64VPOPCNTQ512(v)
+ return rewriteValue_OpAMD64VPOPCNTQ512(v)
case ssaop.OpAMD64VPOPCNTQMasked128:
- return rewriteValueAMD64_OpAMD64VPOPCNTQMasked128(v)
+ return rewriteValue_OpAMD64VPOPCNTQMasked128(v)
case ssaop.OpAMD64VPOPCNTQMasked256:
- return rewriteValueAMD64_OpAMD64VPOPCNTQMasked256(v)
+ return rewriteValue_OpAMD64VPOPCNTQMasked256(v)
case ssaop.OpAMD64VPOPCNTQMasked512:
- return rewriteValueAMD64_OpAMD64VPOPCNTQMasked512(v)
+ return rewriteValue_OpAMD64VPOPCNTQMasked512(v)
case ssaop.OpAMD64VPOPCNTW128:
- return rewriteValueAMD64_OpAMD64VPOPCNTW128(v)
+ return rewriteValue_OpAMD64VPOPCNTW128(v)
case ssaop.OpAMD64VPOPCNTW256:
- return rewriteValueAMD64_OpAMD64VPOPCNTW256(v)
+ return rewriteValue_OpAMD64VPOPCNTW256(v)
case ssaop.OpAMD64VPOPCNTWMasked128:
- return rewriteValueAMD64_OpAMD64VPOPCNTWMasked128(v)
+ return rewriteValue_OpAMD64VPOPCNTWMasked128(v)
case ssaop.OpAMD64VPOPCNTWMasked256:
- return rewriteValueAMD64_OpAMD64VPOPCNTWMasked256(v)
+ return rewriteValue_OpAMD64VPOPCNTWMasked256(v)
case ssaop.OpAMD64VPOR128:
- return rewriteValueAMD64_OpAMD64VPOR128(v)
+ return rewriteValue_OpAMD64VPOR128(v)
case ssaop.OpAMD64VPOR256:
- return rewriteValueAMD64_OpAMD64VPOR256(v)
+ return rewriteValue_OpAMD64VPOR256(v)
case ssaop.OpAMD64VPORD512:
- return rewriteValueAMD64_OpAMD64VPORD512(v)
+ return rewriteValue_OpAMD64VPORD512(v)
case ssaop.OpAMD64VPORDMasked128:
- return rewriteValueAMD64_OpAMD64VPORDMasked128(v)
+ return rewriteValue_OpAMD64VPORDMasked128(v)
case ssaop.OpAMD64VPORDMasked256:
- return rewriteValueAMD64_OpAMD64VPORDMasked256(v)
+ return rewriteValue_OpAMD64VPORDMasked256(v)
case ssaop.OpAMD64VPORDMasked512:
- return rewriteValueAMD64_OpAMD64VPORDMasked512(v)
+ return rewriteValue_OpAMD64VPORDMasked512(v)
case ssaop.OpAMD64VPORQ512:
- return rewriteValueAMD64_OpAMD64VPORQ512(v)
+ return rewriteValue_OpAMD64VPORQ512(v)
case ssaop.OpAMD64VPORQMasked128:
- return rewriteValueAMD64_OpAMD64VPORQMasked128(v)
+ return rewriteValue_OpAMD64VPORQMasked128(v)
case ssaop.OpAMD64VPORQMasked256:
- return rewriteValueAMD64_OpAMD64VPORQMasked256(v)
+ return rewriteValue_OpAMD64VPORQMasked256(v)
case ssaop.OpAMD64VPORQMasked512:
- return rewriteValueAMD64_OpAMD64VPORQMasked512(v)
+ return rewriteValue_OpAMD64VPORQMasked512(v)
case ssaop.OpAMD64VPROLD128:
- return rewriteValueAMD64_OpAMD64VPROLD128(v)
+ return rewriteValue_OpAMD64VPROLD128(v)
case ssaop.OpAMD64VPROLD256:
- return rewriteValueAMD64_OpAMD64VPROLD256(v)
+ return rewriteValue_OpAMD64VPROLD256(v)
case ssaop.OpAMD64VPROLD512:
- return rewriteValueAMD64_OpAMD64VPROLD512(v)
+ return rewriteValue_OpAMD64VPROLD512(v)
case ssaop.OpAMD64VPROLDMasked128:
- return rewriteValueAMD64_OpAMD64VPROLDMasked128(v)
+ return rewriteValue_OpAMD64VPROLDMasked128(v)
case ssaop.OpAMD64VPROLDMasked256:
- return rewriteValueAMD64_OpAMD64VPROLDMasked256(v)
+ return rewriteValue_OpAMD64VPROLDMasked256(v)
case ssaop.OpAMD64VPROLDMasked512:
- return rewriteValueAMD64_OpAMD64VPROLDMasked512(v)
+ return rewriteValue_OpAMD64VPROLDMasked512(v)
case ssaop.OpAMD64VPROLQ128:
- return rewriteValueAMD64_OpAMD64VPROLQ128(v)
+ return rewriteValue_OpAMD64VPROLQ128(v)
case ssaop.OpAMD64VPROLQ256:
- return rewriteValueAMD64_OpAMD64VPROLQ256(v)
+ return rewriteValue_OpAMD64VPROLQ256(v)
case ssaop.OpAMD64VPROLQ512:
- return rewriteValueAMD64_OpAMD64VPROLQ512(v)
+ return rewriteValue_OpAMD64VPROLQ512(v)
case ssaop.OpAMD64VPROLQMasked128:
- return rewriteValueAMD64_OpAMD64VPROLQMasked128(v)
+ return rewriteValue_OpAMD64VPROLQMasked128(v)
case ssaop.OpAMD64VPROLQMasked256:
- return rewriteValueAMD64_OpAMD64VPROLQMasked256(v)
+ return rewriteValue_OpAMD64VPROLQMasked256(v)
case ssaop.OpAMD64VPROLQMasked512:
- return rewriteValueAMD64_OpAMD64VPROLQMasked512(v)
+ return rewriteValue_OpAMD64VPROLQMasked512(v)
case ssaop.OpAMD64VPROLVD128:
- return rewriteValueAMD64_OpAMD64VPROLVD128(v)
+ return rewriteValue_OpAMD64VPROLVD128(v)
case ssaop.OpAMD64VPROLVD256:
- return rewriteValueAMD64_OpAMD64VPROLVD256(v)
+ return rewriteValue_OpAMD64VPROLVD256(v)
case ssaop.OpAMD64VPROLVD512:
- return rewriteValueAMD64_OpAMD64VPROLVD512(v)
+ return rewriteValue_OpAMD64VPROLVD512(v)
case ssaop.OpAMD64VPROLVDMasked128:
- return rewriteValueAMD64_OpAMD64VPROLVDMasked128(v)
+ return rewriteValue_OpAMD64VPROLVDMasked128(v)
case ssaop.OpAMD64VPROLVDMasked256:
- return rewriteValueAMD64_OpAMD64VPROLVDMasked256(v)
+ return rewriteValue_OpAMD64VPROLVDMasked256(v)
case ssaop.OpAMD64VPROLVDMasked512:
- return rewriteValueAMD64_OpAMD64VPROLVDMasked512(v)
+ return rewriteValue_OpAMD64VPROLVDMasked512(v)
case ssaop.OpAMD64VPROLVQ128:
- return rewriteValueAMD64_OpAMD64VPROLVQ128(v)
+ return rewriteValue_OpAMD64VPROLVQ128(v)
case ssaop.OpAMD64VPROLVQ256:
- return rewriteValueAMD64_OpAMD64VPROLVQ256(v)
+ return rewriteValue_OpAMD64VPROLVQ256(v)
case ssaop.OpAMD64VPROLVQ512:
- return rewriteValueAMD64_OpAMD64VPROLVQ512(v)
+ return rewriteValue_OpAMD64VPROLVQ512(v)
case ssaop.OpAMD64VPROLVQMasked128:
- return rewriteValueAMD64_OpAMD64VPROLVQMasked128(v)
+ return rewriteValue_OpAMD64VPROLVQMasked128(v)
case ssaop.OpAMD64VPROLVQMasked256:
- return rewriteValueAMD64_OpAMD64VPROLVQMasked256(v)
+ return rewriteValue_OpAMD64VPROLVQMasked256(v)
case ssaop.OpAMD64VPROLVQMasked512:
- return rewriteValueAMD64_OpAMD64VPROLVQMasked512(v)
+ return rewriteValue_OpAMD64VPROLVQMasked512(v)
case ssaop.OpAMD64VPRORD128:
- return rewriteValueAMD64_OpAMD64VPRORD128(v)
+ return rewriteValue_OpAMD64VPRORD128(v)
case ssaop.OpAMD64VPRORD256:
- return rewriteValueAMD64_OpAMD64VPRORD256(v)
+ return rewriteValue_OpAMD64VPRORD256(v)
case ssaop.OpAMD64VPRORD512:
- return rewriteValueAMD64_OpAMD64VPRORD512(v)
+ return rewriteValue_OpAMD64VPRORD512(v)
case ssaop.OpAMD64VPRORDMasked128:
- return rewriteValueAMD64_OpAMD64VPRORDMasked128(v)
+ return rewriteValue_OpAMD64VPRORDMasked128(v)
case ssaop.OpAMD64VPRORDMasked256:
- return rewriteValueAMD64_OpAMD64VPRORDMasked256(v)
+ return rewriteValue_OpAMD64VPRORDMasked256(v)
case ssaop.OpAMD64VPRORDMasked512:
- return rewriteValueAMD64_OpAMD64VPRORDMasked512(v)
+ return rewriteValue_OpAMD64VPRORDMasked512(v)
case ssaop.OpAMD64VPRORQ128:
- return rewriteValueAMD64_OpAMD64VPRORQ128(v)
+ return rewriteValue_OpAMD64VPRORQ128(v)
case ssaop.OpAMD64VPRORQ256:
- return rewriteValueAMD64_OpAMD64VPRORQ256(v)
+ return rewriteValue_OpAMD64VPRORQ256(v)
case ssaop.OpAMD64VPRORQ512:
- return rewriteValueAMD64_OpAMD64VPRORQ512(v)
+ return rewriteValue_OpAMD64VPRORQ512(v)
case ssaop.OpAMD64VPRORQMasked128:
- return rewriteValueAMD64_OpAMD64VPRORQMasked128(v)
+ return rewriteValue_OpAMD64VPRORQMasked128(v)
case ssaop.OpAMD64VPRORQMasked256:
- return rewriteValueAMD64_OpAMD64VPRORQMasked256(v)
+ return rewriteValue_OpAMD64VPRORQMasked256(v)
case ssaop.OpAMD64VPRORQMasked512:
- return rewriteValueAMD64_OpAMD64VPRORQMasked512(v)
+ return rewriteValue_OpAMD64VPRORQMasked512(v)
case ssaop.OpAMD64VPRORVD128:
- return rewriteValueAMD64_OpAMD64VPRORVD128(v)
+ return rewriteValue_OpAMD64VPRORVD128(v)
case ssaop.OpAMD64VPRORVD256:
- return rewriteValueAMD64_OpAMD64VPRORVD256(v)
+ return rewriteValue_OpAMD64VPRORVD256(v)
case ssaop.OpAMD64VPRORVD512:
- return rewriteValueAMD64_OpAMD64VPRORVD512(v)
+ return rewriteValue_OpAMD64VPRORVD512(v)
case ssaop.OpAMD64VPRORVDMasked128:
- return rewriteValueAMD64_OpAMD64VPRORVDMasked128(v)
+ return rewriteValue_OpAMD64VPRORVDMasked128(v)
case ssaop.OpAMD64VPRORVDMasked256:
- return rewriteValueAMD64_OpAMD64VPRORVDMasked256(v)
+ return rewriteValue_OpAMD64VPRORVDMasked256(v)
case ssaop.OpAMD64VPRORVDMasked512:
- return rewriteValueAMD64_OpAMD64VPRORVDMasked512(v)
+ return rewriteValue_OpAMD64VPRORVDMasked512(v)
case ssaop.OpAMD64VPRORVQ128:
- return rewriteValueAMD64_OpAMD64VPRORVQ128(v)
+ return rewriteValue_OpAMD64VPRORVQ128(v)
case ssaop.OpAMD64VPRORVQ256:
- return rewriteValueAMD64_OpAMD64VPRORVQ256(v)
+ return rewriteValue_OpAMD64VPRORVQ256(v)
case ssaop.OpAMD64VPRORVQ512:
- return rewriteValueAMD64_OpAMD64VPRORVQ512(v)
+ return rewriteValue_OpAMD64VPRORVQ512(v)
case ssaop.OpAMD64VPRORVQMasked128:
- return rewriteValueAMD64_OpAMD64VPRORVQMasked128(v)
+ return rewriteValue_OpAMD64VPRORVQMasked128(v)
case ssaop.OpAMD64VPRORVQMasked256:
- return rewriteValueAMD64_OpAMD64VPRORVQMasked256(v)
+ return rewriteValue_OpAMD64VPRORVQMasked256(v)
case ssaop.OpAMD64VPRORVQMasked512:
- return rewriteValueAMD64_OpAMD64VPRORVQMasked512(v)
+ return rewriteValue_OpAMD64VPRORVQMasked512(v)
case ssaop.OpAMD64VPSADBW128:
- return rewriteValueAMD64_OpAMD64VPSADBW128(v)
+ return rewriteValue_OpAMD64VPSADBW128(v)
case ssaop.OpAMD64VPSADBW256:
- return rewriteValueAMD64_OpAMD64VPSADBW256(v)
+ return rewriteValue_OpAMD64VPSADBW256(v)
case ssaop.OpAMD64VPSHLDD128:
- return rewriteValueAMD64_OpAMD64VPSHLDD128(v)
+ return rewriteValue_OpAMD64VPSHLDD128(v)
case ssaop.OpAMD64VPSHLDD256:
- return rewriteValueAMD64_OpAMD64VPSHLDD256(v)
+ return rewriteValue_OpAMD64VPSHLDD256(v)
case ssaop.OpAMD64VPSHLDD512:
- return rewriteValueAMD64_OpAMD64VPSHLDD512(v)
+ return rewriteValue_OpAMD64VPSHLDD512(v)
case ssaop.OpAMD64VPSHLDDMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDDMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDDMasked128(v)
case ssaop.OpAMD64VPSHLDDMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDDMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDDMasked256(v)
case ssaop.OpAMD64VPSHLDDMasked512:
- return rewriteValueAMD64_OpAMD64VPSHLDDMasked512(v)
+ return rewriteValue_OpAMD64VPSHLDDMasked512(v)
case ssaop.OpAMD64VPSHLDQ128:
- return rewriteValueAMD64_OpAMD64VPSHLDQ128(v)
+ return rewriteValue_OpAMD64VPSHLDQ128(v)
case ssaop.OpAMD64VPSHLDQ256:
- return rewriteValueAMD64_OpAMD64VPSHLDQ256(v)
+ return rewriteValue_OpAMD64VPSHLDQ256(v)
case ssaop.OpAMD64VPSHLDQ512:
- return rewriteValueAMD64_OpAMD64VPSHLDQ512(v)
+ return rewriteValue_OpAMD64VPSHLDQ512(v)
case ssaop.OpAMD64VPSHLDQMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDQMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDQMasked128(v)
case ssaop.OpAMD64VPSHLDQMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDQMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDQMasked256(v)
case ssaop.OpAMD64VPSHLDQMasked512:
- return rewriteValueAMD64_OpAMD64VPSHLDQMasked512(v)
+ return rewriteValue_OpAMD64VPSHLDQMasked512(v)
case ssaop.OpAMD64VPSHLDVD128:
- return rewriteValueAMD64_OpAMD64VPSHLDVD128(v)
+ return rewriteValue_OpAMD64VPSHLDVD128(v)
case ssaop.OpAMD64VPSHLDVD256:
- return rewriteValueAMD64_OpAMD64VPSHLDVD256(v)
+ return rewriteValue_OpAMD64VPSHLDVD256(v)
case ssaop.OpAMD64VPSHLDVD512:
- return rewriteValueAMD64_OpAMD64VPSHLDVD512(v)
+ return rewriteValue_OpAMD64VPSHLDVD512(v)
case ssaop.OpAMD64VPSHLDVDMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDVDMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDVDMasked128(v)
case ssaop.OpAMD64VPSHLDVDMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDVDMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDVDMasked256(v)
case ssaop.OpAMD64VPSHLDVDMasked512:
- return rewriteValueAMD64_OpAMD64VPSHLDVDMasked512(v)
+ return rewriteValue_OpAMD64VPSHLDVDMasked512(v)
case ssaop.OpAMD64VPSHLDVQ128:
- return rewriteValueAMD64_OpAMD64VPSHLDVQ128(v)
+ return rewriteValue_OpAMD64VPSHLDVQ128(v)
case ssaop.OpAMD64VPSHLDVQ256:
- return rewriteValueAMD64_OpAMD64VPSHLDVQ256(v)
+ return rewriteValue_OpAMD64VPSHLDVQ256(v)
case ssaop.OpAMD64VPSHLDVQ512:
- return rewriteValueAMD64_OpAMD64VPSHLDVQ512(v)
+ return rewriteValue_OpAMD64VPSHLDVQ512(v)
case ssaop.OpAMD64VPSHLDVQMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDVQMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDVQMasked128(v)
case ssaop.OpAMD64VPSHLDVQMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDVQMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDVQMasked256(v)
case ssaop.OpAMD64VPSHLDVQMasked512:
- return rewriteValueAMD64_OpAMD64VPSHLDVQMasked512(v)
+ return rewriteValue_OpAMD64VPSHLDVQMasked512(v)
case ssaop.OpAMD64VPSHLDVW128:
- return rewriteValueAMD64_OpAMD64VPSHLDVW128(v)
+ return rewriteValue_OpAMD64VPSHLDVW128(v)
case ssaop.OpAMD64VPSHLDVW256:
- return rewriteValueAMD64_OpAMD64VPSHLDVW256(v)
+ return rewriteValue_OpAMD64VPSHLDVW256(v)
case ssaop.OpAMD64VPSHLDVWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDVWMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDVWMasked128(v)
case ssaop.OpAMD64VPSHLDVWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDVWMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDVWMasked256(v)
case ssaop.OpAMD64VPSHLDW128:
- return rewriteValueAMD64_OpAMD64VPSHLDW128(v)
+ return rewriteValue_OpAMD64VPSHLDW128(v)
case ssaop.OpAMD64VPSHLDW256:
- return rewriteValueAMD64_OpAMD64VPSHLDW256(v)
+ return rewriteValue_OpAMD64VPSHLDW256(v)
case ssaop.OpAMD64VPSHLDWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHLDWMasked128(v)
+ return rewriteValue_OpAMD64VPSHLDWMasked128(v)
case ssaop.OpAMD64VPSHLDWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHLDWMasked256(v)
+ return rewriteValue_OpAMD64VPSHLDWMasked256(v)
case ssaop.OpAMD64VPSHRDD128:
- return rewriteValueAMD64_OpAMD64VPSHRDD128(v)
+ return rewriteValue_OpAMD64VPSHRDD128(v)
case ssaop.OpAMD64VPSHRDD256:
- return rewriteValueAMD64_OpAMD64VPSHRDD256(v)
+ return rewriteValue_OpAMD64VPSHRDD256(v)
case ssaop.OpAMD64VPSHRDD512:
- return rewriteValueAMD64_OpAMD64VPSHRDD512(v)
+ return rewriteValue_OpAMD64VPSHRDD512(v)
case ssaop.OpAMD64VPSHRDDMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDDMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDDMasked128(v)
case ssaop.OpAMD64VPSHRDDMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDDMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDDMasked256(v)
case ssaop.OpAMD64VPSHRDDMasked512:
- return rewriteValueAMD64_OpAMD64VPSHRDDMasked512(v)
+ return rewriteValue_OpAMD64VPSHRDDMasked512(v)
case ssaop.OpAMD64VPSHRDQ128:
- return rewriteValueAMD64_OpAMD64VPSHRDQ128(v)
+ return rewriteValue_OpAMD64VPSHRDQ128(v)
case ssaop.OpAMD64VPSHRDQ256:
- return rewriteValueAMD64_OpAMD64VPSHRDQ256(v)
+ return rewriteValue_OpAMD64VPSHRDQ256(v)
case ssaop.OpAMD64VPSHRDQ512:
- return rewriteValueAMD64_OpAMD64VPSHRDQ512(v)
+ return rewriteValue_OpAMD64VPSHRDQ512(v)
case ssaop.OpAMD64VPSHRDQMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDQMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDQMasked128(v)
case ssaop.OpAMD64VPSHRDQMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDQMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDQMasked256(v)
case ssaop.OpAMD64VPSHRDQMasked512:
- return rewriteValueAMD64_OpAMD64VPSHRDQMasked512(v)
+ return rewriteValue_OpAMD64VPSHRDQMasked512(v)
case ssaop.OpAMD64VPSHRDVD128:
- return rewriteValueAMD64_OpAMD64VPSHRDVD128(v)
+ return rewriteValue_OpAMD64VPSHRDVD128(v)
case ssaop.OpAMD64VPSHRDVD256:
- return rewriteValueAMD64_OpAMD64VPSHRDVD256(v)
+ return rewriteValue_OpAMD64VPSHRDVD256(v)
case ssaop.OpAMD64VPSHRDVD512:
- return rewriteValueAMD64_OpAMD64VPSHRDVD512(v)
+ return rewriteValue_OpAMD64VPSHRDVD512(v)
case ssaop.OpAMD64VPSHRDVDMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDVDMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDVDMasked128(v)
case ssaop.OpAMD64VPSHRDVDMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDVDMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDVDMasked256(v)
case ssaop.OpAMD64VPSHRDVDMasked512:
- return rewriteValueAMD64_OpAMD64VPSHRDVDMasked512(v)
+ return rewriteValue_OpAMD64VPSHRDVDMasked512(v)
case ssaop.OpAMD64VPSHRDVQ128:
- return rewriteValueAMD64_OpAMD64VPSHRDVQ128(v)
+ return rewriteValue_OpAMD64VPSHRDVQ128(v)
case ssaop.OpAMD64VPSHRDVQ256:
- return rewriteValueAMD64_OpAMD64VPSHRDVQ256(v)
+ return rewriteValue_OpAMD64VPSHRDVQ256(v)
case ssaop.OpAMD64VPSHRDVQ512:
- return rewriteValueAMD64_OpAMD64VPSHRDVQ512(v)
+ return rewriteValue_OpAMD64VPSHRDVQ512(v)
case ssaop.OpAMD64VPSHRDVQMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDVQMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDVQMasked128(v)
case ssaop.OpAMD64VPSHRDVQMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDVQMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDVQMasked256(v)
case ssaop.OpAMD64VPSHRDVQMasked512:
- return rewriteValueAMD64_OpAMD64VPSHRDVQMasked512(v)
+ return rewriteValue_OpAMD64VPSHRDVQMasked512(v)
case ssaop.OpAMD64VPSHRDVW128:
- return rewriteValueAMD64_OpAMD64VPSHRDVW128(v)
+ return rewriteValue_OpAMD64VPSHRDVW128(v)
case ssaop.OpAMD64VPSHRDVW256:
- return rewriteValueAMD64_OpAMD64VPSHRDVW256(v)
+ return rewriteValue_OpAMD64VPSHRDVW256(v)
case ssaop.OpAMD64VPSHRDVWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDVWMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDVWMasked128(v)
case ssaop.OpAMD64VPSHRDVWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDVWMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDVWMasked256(v)
case ssaop.OpAMD64VPSHRDW128:
- return rewriteValueAMD64_OpAMD64VPSHRDW128(v)
+ return rewriteValue_OpAMD64VPSHRDW128(v)
case ssaop.OpAMD64VPSHRDW256:
- return rewriteValueAMD64_OpAMD64VPSHRDW256(v)
+ return rewriteValue_OpAMD64VPSHRDW256(v)
case ssaop.OpAMD64VPSHRDWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHRDWMasked128(v)
+ return rewriteValue_OpAMD64VPSHRDWMasked128(v)
case ssaop.OpAMD64VPSHRDWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHRDWMasked256(v)
+ return rewriteValue_OpAMD64VPSHRDWMasked256(v)
case ssaop.OpAMD64VPSHUFB128:
- return rewriteValueAMD64_OpAMD64VPSHUFB128(v)
+ return rewriteValue_OpAMD64VPSHUFB128(v)
case ssaop.OpAMD64VPSHUFB256:
- return rewriteValueAMD64_OpAMD64VPSHUFB256(v)
+ return rewriteValue_OpAMD64VPSHUFB256(v)
case ssaop.OpAMD64VPSHUFBMasked128:
- return rewriteValueAMD64_OpAMD64VPSHUFBMasked128(v)
+ return rewriteValue_OpAMD64VPSHUFBMasked128(v)
case ssaop.OpAMD64VPSHUFBMasked256:
- return rewriteValueAMD64_OpAMD64VPSHUFBMasked256(v)
+ return rewriteValue_OpAMD64VPSHUFBMasked256(v)
case ssaop.OpAMD64VPSHUFD128:
- return rewriteValueAMD64_OpAMD64VPSHUFD128(v)
+ return rewriteValue_OpAMD64VPSHUFD128(v)
case ssaop.OpAMD64VPSHUFD256:
- return rewriteValueAMD64_OpAMD64VPSHUFD256(v)
+ return rewriteValue_OpAMD64VPSHUFD256(v)
case ssaop.OpAMD64VPSHUFD512:
- return rewriteValueAMD64_OpAMD64VPSHUFD512(v)
+ return rewriteValue_OpAMD64VPSHUFD512(v)
case ssaop.OpAMD64VPSHUFDMasked128:
- return rewriteValueAMD64_OpAMD64VPSHUFDMasked128(v)
+ return rewriteValue_OpAMD64VPSHUFDMasked128(v)
case ssaop.OpAMD64VPSHUFDMasked256:
- return rewriteValueAMD64_OpAMD64VPSHUFDMasked256(v)
+ return rewriteValue_OpAMD64VPSHUFDMasked256(v)
case ssaop.OpAMD64VPSHUFDMasked512:
- return rewriteValueAMD64_OpAMD64VPSHUFDMasked512(v)
+ return rewriteValue_OpAMD64VPSHUFDMasked512(v)
case ssaop.OpAMD64VPSHUFHW128:
- return rewriteValueAMD64_OpAMD64VPSHUFHW128(v)
+ return rewriteValue_OpAMD64VPSHUFHW128(v)
case ssaop.OpAMD64VPSHUFHW256:
- return rewriteValueAMD64_OpAMD64VPSHUFHW256(v)
+ return rewriteValue_OpAMD64VPSHUFHW256(v)
case ssaop.OpAMD64VPSHUFHWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHUFHWMasked128(v)
+ return rewriteValue_OpAMD64VPSHUFHWMasked128(v)
case ssaop.OpAMD64VPSHUFHWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHUFHWMasked256(v)
+ return rewriteValue_OpAMD64VPSHUFHWMasked256(v)
case ssaop.OpAMD64VPSHUFLW128:
- return rewriteValueAMD64_OpAMD64VPSHUFLW128(v)
+ return rewriteValue_OpAMD64VPSHUFLW128(v)
case ssaop.OpAMD64VPSHUFLW256:
- return rewriteValueAMD64_OpAMD64VPSHUFLW256(v)
+ return rewriteValue_OpAMD64VPSHUFLW256(v)
case ssaop.OpAMD64VPSHUFLWMasked128:
- return rewriteValueAMD64_OpAMD64VPSHUFLWMasked128(v)
+ return rewriteValue_OpAMD64VPSHUFLWMasked128(v)
case ssaop.OpAMD64VPSHUFLWMasked256:
- return rewriteValueAMD64_OpAMD64VPSHUFLWMasked256(v)
+ return rewriteValue_OpAMD64VPSHUFLWMasked256(v)
case ssaop.OpAMD64VPSIGNB128:
- return rewriteValueAMD64_OpAMD64VPSIGNB128(v)
+ return rewriteValue_OpAMD64VPSIGNB128(v)
case ssaop.OpAMD64VPSIGNB256:
- return rewriteValueAMD64_OpAMD64VPSIGNB256(v)
+ return rewriteValue_OpAMD64VPSIGNB256(v)
case ssaop.OpAMD64VPSIGND128:
- return rewriteValueAMD64_OpAMD64VPSIGND128(v)
+ return rewriteValue_OpAMD64VPSIGND128(v)
case ssaop.OpAMD64VPSIGND256:
- return rewriteValueAMD64_OpAMD64VPSIGND256(v)
+ return rewriteValue_OpAMD64VPSIGND256(v)
case ssaop.OpAMD64VPSIGNW128:
- return rewriteValueAMD64_OpAMD64VPSIGNW128(v)
+ return rewriteValue_OpAMD64VPSIGNW128(v)
case ssaop.OpAMD64VPSIGNW256:
- return rewriteValueAMD64_OpAMD64VPSIGNW256(v)
+ return rewriteValue_OpAMD64VPSIGNW256(v)
case ssaop.OpAMD64VPSLLD128:
- return rewriteValueAMD64_OpAMD64VPSLLD128(v)
+ return rewriteValue_OpAMD64VPSLLD128(v)
case ssaop.OpAMD64VPSLLD128const:
- return rewriteValueAMD64_OpAMD64VPSLLD128const(v)
+ return rewriteValue_OpAMD64VPSLLD128const(v)
case ssaop.OpAMD64VPSLLD256:
- return rewriteValueAMD64_OpAMD64VPSLLD256(v)
+ return rewriteValue_OpAMD64VPSLLD256(v)
case ssaop.OpAMD64VPSLLD256const:
- return rewriteValueAMD64_OpAMD64VPSLLD256const(v)
+ return rewriteValue_OpAMD64VPSLLD256const(v)
case ssaop.OpAMD64VPSLLD512:
- return rewriteValueAMD64_OpAMD64VPSLLD512(v)
+ return rewriteValue_OpAMD64VPSLLD512(v)
case ssaop.OpAMD64VPSLLD512const:
- return rewriteValueAMD64_OpAMD64VPSLLD512const(v)
+ return rewriteValue_OpAMD64VPSLLD512const(v)
case ssaop.OpAMD64VPSLLDMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked128(v)
+ return rewriteValue_OpAMD64VPSLLDMasked128(v)
case ssaop.OpAMD64VPSLLDMasked128const:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked128const(v)
+ return rewriteValue_OpAMD64VPSLLDMasked128const(v)
case ssaop.OpAMD64VPSLLDMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked256(v)
+ return rewriteValue_OpAMD64VPSLLDMasked256(v)
case ssaop.OpAMD64VPSLLDMasked256const:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked256const(v)
+ return rewriteValue_OpAMD64VPSLLDMasked256const(v)
case ssaop.OpAMD64VPSLLDMasked512:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked512(v)
+ return rewriteValue_OpAMD64VPSLLDMasked512(v)
case ssaop.OpAMD64VPSLLDMasked512const:
- return rewriteValueAMD64_OpAMD64VPSLLDMasked512const(v)
+ return rewriteValue_OpAMD64VPSLLDMasked512const(v)
case ssaop.OpAMD64VPSLLQ128:
- return rewriteValueAMD64_OpAMD64VPSLLQ128(v)
+ return rewriteValue_OpAMD64VPSLLQ128(v)
case ssaop.OpAMD64VPSLLQ128const:
- return rewriteValueAMD64_OpAMD64VPSLLQ128const(v)
+ return rewriteValue_OpAMD64VPSLLQ128const(v)
case ssaop.OpAMD64VPSLLQ256:
- return rewriteValueAMD64_OpAMD64VPSLLQ256(v)
+ return rewriteValue_OpAMD64VPSLLQ256(v)
case ssaop.OpAMD64VPSLLQ256const:
- return rewriteValueAMD64_OpAMD64VPSLLQ256const(v)
+ return rewriteValue_OpAMD64VPSLLQ256const(v)
case ssaop.OpAMD64VPSLLQ512:
- return rewriteValueAMD64_OpAMD64VPSLLQ512(v)
+ return rewriteValue_OpAMD64VPSLLQ512(v)
case ssaop.OpAMD64VPSLLQ512const:
- return rewriteValueAMD64_OpAMD64VPSLLQ512const(v)
+ return rewriteValue_OpAMD64VPSLLQ512const(v)
case ssaop.OpAMD64VPSLLQMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked128(v)
+ return rewriteValue_OpAMD64VPSLLQMasked128(v)
case ssaop.OpAMD64VPSLLQMasked128const:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked128const(v)
+ return rewriteValue_OpAMD64VPSLLQMasked128const(v)
case ssaop.OpAMD64VPSLLQMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked256(v)
+ return rewriteValue_OpAMD64VPSLLQMasked256(v)
case ssaop.OpAMD64VPSLLQMasked256const:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked256const(v)
+ return rewriteValue_OpAMD64VPSLLQMasked256const(v)
case ssaop.OpAMD64VPSLLQMasked512:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked512(v)
+ return rewriteValue_OpAMD64VPSLLQMasked512(v)
case ssaop.OpAMD64VPSLLQMasked512const:
- return rewriteValueAMD64_OpAMD64VPSLLQMasked512const(v)
+ return rewriteValue_OpAMD64VPSLLQMasked512const(v)
case ssaop.OpAMD64VPSLLVD128:
- return rewriteValueAMD64_OpAMD64VPSLLVD128(v)
+ return rewriteValue_OpAMD64VPSLLVD128(v)
case ssaop.OpAMD64VPSLLVD256:
- return rewriteValueAMD64_OpAMD64VPSLLVD256(v)
+ return rewriteValue_OpAMD64VPSLLVD256(v)
case ssaop.OpAMD64VPSLLVD512:
- return rewriteValueAMD64_OpAMD64VPSLLVD512(v)
+ return rewriteValue_OpAMD64VPSLLVD512(v)
case ssaop.OpAMD64VPSLLVDMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLVDMasked128(v)
+ return rewriteValue_OpAMD64VPSLLVDMasked128(v)
case ssaop.OpAMD64VPSLLVDMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLVDMasked256(v)
+ return rewriteValue_OpAMD64VPSLLVDMasked256(v)
case ssaop.OpAMD64VPSLLVDMasked512:
- return rewriteValueAMD64_OpAMD64VPSLLVDMasked512(v)
+ return rewriteValue_OpAMD64VPSLLVDMasked512(v)
case ssaop.OpAMD64VPSLLVQ128:
- return rewriteValueAMD64_OpAMD64VPSLLVQ128(v)
+ return rewriteValue_OpAMD64VPSLLVQ128(v)
case ssaop.OpAMD64VPSLLVQ256:
- return rewriteValueAMD64_OpAMD64VPSLLVQ256(v)
+ return rewriteValue_OpAMD64VPSLLVQ256(v)
case ssaop.OpAMD64VPSLLVQ512:
- return rewriteValueAMD64_OpAMD64VPSLLVQ512(v)
+ return rewriteValue_OpAMD64VPSLLVQ512(v)
case ssaop.OpAMD64VPSLLVQMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLVQMasked128(v)
+ return rewriteValue_OpAMD64VPSLLVQMasked128(v)
case ssaop.OpAMD64VPSLLVQMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLVQMasked256(v)
+ return rewriteValue_OpAMD64VPSLLVQMasked256(v)
case ssaop.OpAMD64VPSLLVQMasked512:
- return rewriteValueAMD64_OpAMD64VPSLLVQMasked512(v)
+ return rewriteValue_OpAMD64VPSLLVQMasked512(v)
case ssaop.OpAMD64VPSLLVW128:
- return rewriteValueAMD64_OpAMD64VPSLLVW128(v)
+ return rewriteValue_OpAMD64VPSLLVW128(v)
case ssaop.OpAMD64VPSLLVW256:
- return rewriteValueAMD64_OpAMD64VPSLLVW256(v)
+ return rewriteValue_OpAMD64VPSLLVW256(v)
case ssaop.OpAMD64VPSLLVWMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLVWMasked128(v)
+ return rewriteValue_OpAMD64VPSLLVWMasked128(v)
case ssaop.OpAMD64VPSLLVWMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLVWMasked256(v)
+ return rewriteValue_OpAMD64VPSLLVWMasked256(v)
case ssaop.OpAMD64VPSLLW128:
- return rewriteValueAMD64_OpAMD64VPSLLW128(v)
+ return rewriteValue_OpAMD64VPSLLW128(v)
case ssaop.OpAMD64VPSLLW128const:
- return rewriteValueAMD64_OpAMD64VPSLLW128const(v)
+ return rewriteValue_OpAMD64VPSLLW128const(v)
case ssaop.OpAMD64VPSLLW256:
- return rewriteValueAMD64_OpAMD64VPSLLW256(v)
+ return rewriteValue_OpAMD64VPSLLW256(v)
case ssaop.OpAMD64VPSLLW256const:
- return rewriteValueAMD64_OpAMD64VPSLLW256const(v)
+ return rewriteValue_OpAMD64VPSLLW256const(v)
case ssaop.OpAMD64VPSLLW512:
- return rewriteValueAMD64_OpAMD64VPSLLW512(v)
+ return rewriteValue_OpAMD64VPSLLW512(v)
case ssaop.OpAMD64VPSLLW512const:
- return rewriteValueAMD64_OpAMD64VPSLLW512const(v)
+ return rewriteValue_OpAMD64VPSLLW512const(v)
case ssaop.OpAMD64VPSLLWMasked128:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked128(v)
+ return rewriteValue_OpAMD64VPSLLWMasked128(v)
case ssaop.OpAMD64VPSLLWMasked128const:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked128const(v)
+ return rewriteValue_OpAMD64VPSLLWMasked128const(v)
case ssaop.OpAMD64VPSLLWMasked256:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked256(v)
+ return rewriteValue_OpAMD64VPSLLWMasked256(v)
case ssaop.OpAMD64VPSLLWMasked256const:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked256const(v)
+ return rewriteValue_OpAMD64VPSLLWMasked256const(v)
case ssaop.OpAMD64VPSLLWMasked512:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked512(v)
+ return rewriteValue_OpAMD64VPSLLWMasked512(v)
case ssaop.OpAMD64VPSLLWMasked512const:
- return rewriteValueAMD64_OpAMD64VPSLLWMasked512const(v)
+ return rewriteValue_OpAMD64VPSLLWMasked512const(v)
case ssaop.OpAMD64VPSRAD128:
- return rewriteValueAMD64_OpAMD64VPSRAD128(v)
+ return rewriteValue_OpAMD64VPSRAD128(v)
case ssaop.OpAMD64VPSRAD128const:
- return rewriteValueAMD64_OpAMD64VPSRAD128const(v)
+ return rewriteValue_OpAMD64VPSRAD128const(v)
case ssaop.OpAMD64VPSRAD256:
- return rewriteValueAMD64_OpAMD64VPSRAD256(v)
+ return rewriteValue_OpAMD64VPSRAD256(v)
case ssaop.OpAMD64VPSRAD256const:
- return rewriteValueAMD64_OpAMD64VPSRAD256const(v)
+ return rewriteValue_OpAMD64VPSRAD256const(v)
case ssaop.OpAMD64VPSRAD512:
- return rewriteValueAMD64_OpAMD64VPSRAD512(v)
+ return rewriteValue_OpAMD64VPSRAD512(v)
case ssaop.OpAMD64VPSRAD512const:
- return rewriteValueAMD64_OpAMD64VPSRAD512const(v)
+ return rewriteValue_OpAMD64VPSRAD512const(v)
case ssaop.OpAMD64VPSRADMasked128:
- return rewriteValueAMD64_OpAMD64VPSRADMasked128(v)
+ return rewriteValue_OpAMD64VPSRADMasked128(v)
case ssaop.OpAMD64VPSRADMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRADMasked128const(v)
+ return rewriteValue_OpAMD64VPSRADMasked128const(v)
case ssaop.OpAMD64VPSRADMasked256:
- return rewriteValueAMD64_OpAMD64VPSRADMasked256(v)
+ return rewriteValue_OpAMD64VPSRADMasked256(v)
case ssaop.OpAMD64VPSRADMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRADMasked256const(v)
+ return rewriteValue_OpAMD64VPSRADMasked256const(v)
case ssaop.OpAMD64VPSRADMasked512:
- return rewriteValueAMD64_OpAMD64VPSRADMasked512(v)
+ return rewriteValue_OpAMD64VPSRADMasked512(v)
case ssaop.OpAMD64VPSRADMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRADMasked512const(v)
+ return rewriteValue_OpAMD64VPSRADMasked512const(v)
case ssaop.OpAMD64VPSRAQ128:
- return rewriteValueAMD64_OpAMD64VPSRAQ128(v)
+ return rewriteValue_OpAMD64VPSRAQ128(v)
case ssaop.OpAMD64VPSRAQ128const:
- return rewriteValueAMD64_OpAMD64VPSRAQ128const(v)
+ return rewriteValue_OpAMD64VPSRAQ128const(v)
case ssaop.OpAMD64VPSRAQ256:
- return rewriteValueAMD64_OpAMD64VPSRAQ256(v)
+ return rewriteValue_OpAMD64VPSRAQ256(v)
case ssaop.OpAMD64VPSRAQ256const:
- return rewriteValueAMD64_OpAMD64VPSRAQ256const(v)
+ return rewriteValue_OpAMD64VPSRAQ256const(v)
case ssaop.OpAMD64VPSRAQ512:
- return rewriteValueAMD64_OpAMD64VPSRAQ512(v)
+ return rewriteValue_OpAMD64VPSRAQ512(v)
case ssaop.OpAMD64VPSRAQ512const:
- return rewriteValueAMD64_OpAMD64VPSRAQ512const(v)
+ return rewriteValue_OpAMD64VPSRAQ512const(v)
case ssaop.OpAMD64VPSRAQMasked128:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked128(v)
+ return rewriteValue_OpAMD64VPSRAQMasked128(v)
case ssaop.OpAMD64VPSRAQMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked128const(v)
+ return rewriteValue_OpAMD64VPSRAQMasked128const(v)
case ssaop.OpAMD64VPSRAQMasked256:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked256(v)
+ return rewriteValue_OpAMD64VPSRAQMasked256(v)
case ssaop.OpAMD64VPSRAQMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked256const(v)
+ return rewriteValue_OpAMD64VPSRAQMasked256const(v)
case ssaop.OpAMD64VPSRAQMasked512:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked512(v)
+ return rewriteValue_OpAMD64VPSRAQMasked512(v)
case ssaop.OpAMD64VPSRAQMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRAQMasked512const(v)
+ return rewriteValue_OpAMD64VPSRAQMasked512const(v)
case ssaop.OpAMD64VPSRAVD128:
- return rewriteValueAMD64_OpAMD64VPSRAVD128(v)
+ return rewriteValue_OpAMD64VPSRAVD128(v)
case ssaop.OpAMD64VPSRAVD256:
- return rewriteValueAMD64_OpAMD64VPSRAVD256(v)
+ return rewriteValue_OpAMD64VPSRAVD256(v)
case ssaop.OpAMD64VPSRAVD512:
- return rewriteValueAMD64_OpAMD64VPSRAVD512(v)
+ return rewriteValue_OpAMD64VPSRAVD512(v)
case ssaop.OpAMD64VPSRAVDMasked128:
- return rewriteValueAMD64_OpAMD64VPSRAVDMasked128(v)
+ return rewriteValue_OpAMD64VPSRAVDMasked128(v)
case ssaop.OpAMD64VPSRAVDMasked256:
- return rewriteValueAMD64_OpAMD64VPSRAVDMasked256(v)
+ return rewriteValue_OpAMD64VPSRAVDMasked256(v)
case ssaop.OpAMD64VPSRAVDMasked512:
- return rewriteValueAMD64_OpAMD64VPSRAVDMasked512(v)
+ return rewriteValue_OpAMD64VPSRAVDMasked512(v)
case ssaop.OpAMD64VPSRAVQ128:
- return rewriteValueAMD64_OpAMD64VPSRAVQ128(v)
+ return rewriteValue_OpAMD64VPSRAVQ128(v)
case ssaop.OpAMD64VPSRAVQ256:
- return rewriteValueAMD64_OpAMD64VPSRAVQ256(v)
+ return rewriteValue_OpAMD64VPSRAVQ256(v)
case ssaop.OpAMD64VPSRAVQ512:
- return rewriteValueAMD64_OpAMD64VPSRAVQ512(v)
+ return rewriteValue_OpAMD64VPSRAVQ512(v)
case ssaop.OpAMD64VPSRAVQMasked128:
- return rewriteValueAMD64_OpAMD64VPSRAVQMasked128(v)
+ return rewriteValue_OpAMD64VPSRAVQMasked128(v)
case ssaop.OpAMD64VPSRAVQMasked256:
- return rewriteValueAMD64_OpAMD64VPSRAVQMasked256(v)
+ return rewriteValue_OpAMD64VPSRAVQMasked256(v)
case ssaop.OpAMD64VPSRAVQMasked512:
- return rewriteValueAMD64_OpAMD64VPSRAVQMasked512(v)
+ return rewriteValue_OpAMD64VPSRAVQMasked512(v)
case ssaop.OpAMD64VPSRAVW128:
- return rewriteValueAMD64_OpAMD64VPSRAVW128(v)
+ return rewriteValue_OpAMD64VPSRAVW128(v)
case ssaop.OpAMD64VPSRAVW256:
- return rewriteValueAMD64_OpAMD64VPSRAVW256(v)
+ return rewriteValue_OpAMD64VPSRAVW256(v)
case ssaop.OpAMD64VPSRAVWMasked128:
- return rewriteValueAMD64_OpAMD64VPSRAVWMasked128(v)
+ return rewriteValue_OpAMD64VPSRAVWMasked128(v)
case ssaop.OpAMD64VPSRAVWMasked256:
- return rewriteValueAMD64_OpAMD64VPSRAVWMasked256(v)
+ return rewriteValue_OpAMD64VPSRAVWMasked256(v)
case ssaop.OpAMD64VPSRAW128:
- return rewriteValueAMD64_OpAMD64VPSRAW128(v)
+ return rewriteValue_OpAMD64VPSRAW128(v)
case ssaop.OpAMD64VPSRAW128const:
- return rewriteValueAMD64_OpAMD64VPSRAW128const(v)
+ return rewriteValue_OpAMD64VPSRAW128const(v)
case ssaop.OpAMD64VPSRAW256:
- return rewriteValueAMD64_OpAMD64VPSRAW256(v)
+ return rewriteValue_OpAMD64VPSRAW256(v)
case ssaop.OpAMD64VPSRAW256const:
- return rewriteValueAMD64_OpAMD64VPSRAW256const(v)
+ return rewriteValue_OpAMD64VPSRAW256const(v)
case ssaop.OpAMD64VPSRAW512:
- return rewriteValueAMD64_OpAMD64VPSRAW512(v)
+ return rewriteValue_OpAMD64VPSRAW512(v)
case ssaop.OpAMD64VPSRAW512const:
- return rewriteValueAMD64_OpAMD64VPSRAW512const(v)
+ return rewriteValue_OpAMD64VPSRAW512const(v)
case ssaop.OpAMD64VPSRAWMasked128:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked128(v)
+ return rewriteValue_OpAMD64VPSRAWMasked128(v)
case ssaop.OpAMD64VPSRAWMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked128const(v)
+ return rewriteValue_OpAMD64VPSRAWMasked128const(v)
case ssaop.OpAMD64VPSRAWMasked256:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked256(v)
+ return rewriteValue_OpAMD64VPSRAWMasked256(v)
case ssaop.OpAMD64VPSRAWMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked256const(v)
+ return rewriteValue_OpAMD64VPSRAWMasked256const(v)
case ssaop.OpAMD64VPSRAWMasked512:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked512(v)
+ return rewriteValue_OpAMD64VPSRAWMasked512(v)
case ssaop.OpAMD64VPSRAWMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRAWMasked512const(v)
+ return rewriteValue_OpAMD64VPSRAWMasked512const(v)
case ssaop.OpAMD64VPSRLD128:
- return rewriteValueAMD64_OpAMD64VPSRLD128(v)
+ return rewriteValue_OpAMD64VPSRLD128(v)
case ssaop.OpAMD64VPSRLD128const:
- return rewriteValueAMD64_OpAMD64VPSRLD128const(v)
+ return rewriteValue_OpAMD64VPSRLD128const(v)
case ssaop.OpAMD64VPSRLD256:
- return rewriteValueAMD64_OpAMD64VPSRLD256(v)
+ return rewriteValue_OpAMD64VPSRLD256(v)
case ssaop.OpAMD64VPSRLD256const:
- return rewriteValueAMD64_OpAMD64VPSRLD256const(v)
+ return rewriteValue_OpAMD64VPSRLD256const(v)
case ssaop.OpAMD64VPSRLD512:
- return rewriteValueAMD64_OpAMD64VPSRLD512(v)
+ return rewriteValue_OpAMD64VPSRLD512(v)
case ssaop.OpAMD64VPSRLD512const:
- return rewriteValueAMD64_OpAMD64VPSRLD512const(v)
+ return rewriteValue_OpAMD64VPSRLD512const(v)
case ssaop.OpAMD64VPSRLDMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked128(v)
+ return rewriteValue_OpAMD64VPSRLDMasked128(v)
case ssaop.OpAMD64VPSRLDMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked128const(v)
+ return rewriteValue_OpAMD64VPSRLDMasked128const(v)
case ssaop.OpAMD64VPSRLDMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked256(v)
+ return rewriteValue_OpAMD64VPSRLDMasked256(v)
case ssaop.OpAMD64VPSRLDMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked256const(v)
+ return rewriteValue_OpAMD64VPSRLDMasked256const(v)
case ssaop.OpAMD64VPSRLDMasked512:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked512(v)
+ return rewriteValue_OpAMD64VPSRLDMasked512(v)
case ssaop.OpAMD64VPSRLDMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRLDMasked512const(v)
+ return rewriteValue_OpAMD64VPSRLDMasked512const(v)
case ssaop.OpAMD64VPSRLQ128:
- return rewriteValueAMD64_OpAMD64VPSRLQ128(v)
+ return rewriteValue_OpAMD64VPSRLQ128(v)
case ssaop.OpAMD64VPSRLQ128const:
- return rewriteValueAMD64_OpAMD64VPSRLQ128const(v)
+ return rewriteValue_OpAMD64VPSRLQ128const(v)
case ssaop.OpAMD64VPSRLQ256:
- return rewriteValueAMD64_OpAMD64VPSRLQ256(v)
+ return rewriteValue_OpAMD64VPSRLQ256(v)
case ssaop.OpAMD64VPSRLQ256const:
- return rewriteValueAMD64_OpAMD64VPSRLQ256const(v)
+ return rewriteValue_OpAMD64VPSRLQ256const(v)
case ssaop.OpAMD64VPSRLQ512:
- return rewriteValueAMD64_OpAMD64VPSRLQ512(v)
+ return rewriteValue_OpAMD64VPSRLQ512(v)
case ssaop.OpAMD64VPSRLQ512const:
- return rewriteValueAMD64_OpAMD64VPSRLQ512const(v)
+ return rewriteValue_OpAMD64VPSRLQ512const(v)
case ssaop.OpAMD64VPSRLQMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked128(v)
+ return rewriteValue_OpAMD64VPSRLQMasked128(v)
case ssaop.OpAMD64VPSRLQMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked128const(v)
+ return rewriteValue_OpAMD64VPSRLQMasked128const(v)
case ssaop.OpAMD64VPSRLQMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked256(v)
+ return rewriteValue_OpAMD64VPSRLQMasked256(v)
case ssaop.OpAMD64VPSRLQMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked256const(v)
+ return rewriteValue_OpAMD64VPSRLQMasked256const(v)
case ssaop.OpAMD64VPSRLQMasked512:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked512(v)
+ return rewriteValue_OpAMD64VPSRLQMasked512(v)
case ssaop.OpAMD64VPSRLQMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRLQMasked512const(v)
+ return rewriteValue_OpAMD64VPSRLQMasked512const(v)
case ssaop.OpAMD64VPSRLVD128:
- return rewriteValueAMD64_OpAMD64VPSRLVD128(v)
+ return rewriteValue_OpAMD64VPSRLVD128(v)
case ssaop.OpAMD64VPSRLVD256:
- return rewriteValueAMD64_OpAMD64VPSRLVD256(v)
+ return rewriteValue_OpAMD64VPSRLVD256(v)
case ssaop.OpAMD64VPSRLVD512:
- return rewriteValueAMD64_OpAMD64VPSRLVD512(v)
+ return rewriteValue_OpAMD64VPSRLVD512(v)
case ssaop.OpAMD64VPSRLVDMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLVDMasked128(v)
+ return rewriteValue_OpAMD64VPSRLVDMasked128(v)
case ssaop.OpAMD64VPSRLVDMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLVDMasked256(v)
+ return rewriteValue_OpAMD64VPSRLVDMasked256(v)
case ssaop.OpAMD64VPSRLVDMasked512:
- return rewriteValueAMD64_OpAMD64VPSRLVDMasked512(v)
+ return rewriteValue_OpAMD64VPSRLVDMasked512(v)
case ssaop.OpAMD64VPSRLVQ128:
- return rewriteValueAMD64_OpAMD64VPSRLVQ128(v)
+ return rewriteValue_OpAMD64VPSRLVQ128(v)
case ssaop.OpAMD64VPSRLVQ256:
- return rewriteValueAMD64_OpAMD64VPSRLVQ256(v)
+ return rewriteValue_OpAMD64VPSRLVQ256(v)
case ssaop.OpAMD64VPSRLVQ512:
- return rewriteValueAMD64_OpAMD64VPSRLVQ512(v)
+ return rewriteValue_OpAMD64VPSRLVQ512(v)
case ssaop.OpAMD64VPSRLVQMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLVQMasked128(v)
+ return rewriteValue_OpAMD64VPSRLVQMasked128(v)
case ssaop.OpAMD64VPSRLVQMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLVQMasked256(v)
+ return rewriteValue_OpAMD64VPSRLVQMasked256(v)
case ssaop.OpAMD64VPSRLVQMasked512:
- return rewriteValueAMD64_OpAMD64VPSRLVQMasked512(v)
+ return rewriteValue_OpAMD64VPSRLVQMasked512(v)
case ssaop.OpAMD64VPSRLVW128:
- return rewriteValueAMD64_OpAMD64VPSRLVW128(v)
+ return rewriteValue_OpAMD64VPSRLVW128(v)
case ssaop.OpAMD64VPSRLVW256:
- return rewriteValueAMD64_OpAMD64VPSRLVW256(v)
+ return rewriteValue_OpAMD64VPSRLVW256(v)
case ssaop.OpAMD64VPSRLVWMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLVWMasked128(v)
+ return rewriteValue_OpAMD64VPSRLVWMasked128(v)
case ssaop.OpAMD64VPSRLVWMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLVWMasked256(v)
+ return rewriteValue_OpAMD64VPSRLVWMasked256(v)
case ssaop.OpAMD64VPSRLW128:
- return rewriteValueAMD64_OpAMD64VPSRLW128(v)
+ return rewriteValue_OpAMD64VPSRLW128(v)
case ssaop.OpAMD64VPSRLW128const:
- return rewriteValueAMD64_OpAMD64VPSRLW128const(v)
+ return rewriteValue_OpAMD64VPSRLW128const(v)
case ssaop.OpAMD64VPSRLW256:
- return rewriteValueAMD64_OpAMD64VPSRLW256(v)
+ return rewriteValue_OpAMD64VPSRLW256(v)
case ssaop.OpAMD64VPSRLW256const:
- return rewriteValueAMD64_OpAMD64VPSRLW256const(v)
+ return rewriteValue_OpAMD64VPSRLW256const(v)
case ssaop.OpAMD64VPSRLW512:
- return rewriteValueAMD64_OpAMD64VPSRLW512(v)
+ return rewriteValue_OpAMD64VPSRLW512(v)
case ssaop.OpAMD64VPSRLW512const:
- return rewriteValueAMD64_OpAMD64VPSRLW512const(v)
+ return rewriteValue_OpAMD64VPSRLW512const(v)
case ssaop.OpAMD64VPSRLWMasked128:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked128(v)
+ return rewriteValue_OpAMD64VPSRLWMasked128(v)
case ssaop.OpAMD64VPSRLWMasked128const:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked128const(v)
+ return rewriteValue_OpAMD64VPSRLWMasked128const(v)
case ssaop.OpAMD64VPSRLWMasked256:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked256(v)
+ return rewriteValue_OpAMD64VPSRLWMasked256(v)
case ssaop.OpAMD64VPSRLWMasked256const:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked256const(v)
+ return rewriteValue_OpAMD64VPSRLWMasked256const(v)
case ssaop.OpAMD64VPSRLWMasked512:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked512(v)
+ return rewriteValue_OpAMD64VPSRLWMasked512(v)
case ssaop.OpAMD64VPSRLWMasked512const:
- return rewriteValueAMD64_OpAMD64VPSRLWMasked512const(v)
+ return rewriteValue_OpAMD64VPSRLWMasked512const(v)
case ssaop.OpAMD64VPSUBB128:
- return rewriteValueAMD64_OpAMD64VPSUBB128(v)
+ return rewriteValue_OpAMD64VPSUBB128(v)
case ssaop.OpAMD64VPSUBB256:
- return rewriteValueAMD64_OpAMD64VPSUBB256(v)
+ return rewriteValue_OpAMD64VPSUBB256(v)
case ssaop.OpAMD64VPSUBBMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBBMasked128(v)
+ return rewriteValue_OpAMD64VPSUBBMasked128(v)
case ssaop.OpAMD64VPSUBBMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBBMasked256(v)
+ return rewriteValue_OpAMD64VPSUBBMasked256(v)
case ssaop.OpAMD64VPSUBD128:
- return rewriteValueAMD64_OpAMD64VPSUBD128(v)
+ return rewriteValue_OpAMD64VPSUBD128(v)
case ssaop.OpAMD64VPSUBD256:
- return rewriteValueAMD64_OpAMD64VPSUBD256(v)
+ return rewriteValue_OpAMD64VPSUBD256(v)
case ssaop.OpAMD64VPSUBD512:
- return rewriteValueAMD64_OpAMD64VPSUBD512(v)
+ return rewriteValue_OpAMD64VPSUBD512(v)
case ssaop.OpAMD64VPSUBDMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBDMasked128(v)
+ return rewriteValue_OpAMD64VPSUBDMasked128(v)
case ssaop.OpAMD64VPSUBDMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBDMasked256(v)
+ return rewriteValue_OpAMD64VPSUBDMasked256(v)
case ssaop.OpAMD64VPSUBDMasked512:
- return rewriteValueAMD64_OpAMD64VPSUBDMasked512(v)
+ return rewriteValue_OpAMD64VPSUBDMasked512(v)
case ssaop.OpAMD64VPSUBQ128:
- return rewriteValueAMD64_OpAMD64VPSUBQ128(v)
+ return rewriteValue_OpAMD64VPSUBQ128(v)
case ssaop.OpAMD64VPSUBQ256:
- return rewriteValueAMD64_OpAMD64VPSUBQ256(v)
+ return rewriteValue_OpAMD64VPSUBQ256(v)
case ssaop.OpAMD64VPSUBQ512:
- return rewriteValueAMD64_OpAMD64VPSUBQ512(v)
+ return rewriteValue_OpAMD64VPSUBQ512(v)
case ssaop.OpAMD64VPSUBQMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBQMasked128(v)
+ return rewriteValue_OpAMD64VPSUBQMasked128(v)
case ssaop.OpAMD64VPSUBQMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBQMasked256(v)
+ return rewriteValue_OpAMD64VPSUBQMasked256(v)
case ssaop.OpAMD64VPSUBQMasked512:
- return rewriteValueAMD64_OpAMD64VPSUBQMasked512(v)
+ return rewriteValue_OpAMD64VPSUBQMasked512(v)
case ssaop.OpAMD64VPSUBSB128:
- return rewriteValueAMD64_OpAMD64VPSUBSB128(v)
+ return rewriteValue_OpAMD64VPSUBSB128(v)
case ssaop.OpAMD64VPSUBSB256:
- return rewriteValueAMD64_OpAMD64VPSUBSB256(v)
+ return rewriteValue_OpAMD64VPSUBSB256(v)
case ssaop.OpAMD64VPSUBSBMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBSBMasked128(v)
+ return rewriteValue_OpAMD64VPSUBSBMasked128(v)
case ssaop.OpAMD64VPSUBSBMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBSBMasked256(v)
+ return rewriteValue_OpAMD64VPSUBSBMasked256(v)
case ssaop.OpAMD64VPSUBSW128:
- return rewriteValueAMD64_OpAMD64VPSUBSW128(v)
+ return rewriteValue_OpAMD64VPSUBSW128(v)
case ssaop.OpAMD64VPSUBSW256:
- return rewriteValueAMD64_OpAMD64VPSUBSW256(v)
+ return rewriteValue_OpAMD64VPSUBSW256(v)
case ssaop.OpAMD64VPSUBSWMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBSWMasked128(v)
+ return rewriteValue_OpAMD64VPSUBSWMasked128(v)
case ssaop.OpAMD64VPSUBSWMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBSWMasked256(v)
+ return rewriteValue_OpAMD64VPSUBSWMasked256(v)
case ssaop.OpAMD64VPSUBUSB128:
- return rewriteValueAMD64_OpAMD64VPSUBUSB128(v)
+ return rewriteValue_OpAMD64VPSUBUSB128(v)
case ssaop.OpAMD64VPSUBUSB256:
- return rewriteValueAMD64_OpAMD64VPSUBUSB256(v)
+ return rewriteValue_OpAMD64VPSUBUSB256(v)
case ssaop.OpAMD64VPSUBUSBMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBUSBMasked128(v)
+ return rewriteValue_OpAMD64VPSUBUSBMasked128(v)
case ssaop.OpAMD64VPSUBUSBMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBUSBMasked256(v)
+ return rewriteValue_OpAMD64VPSUBUSBMasked256(v)
case ssaop.OpAMD64VPSUBUSW128:
- return rewriteValueAMD64_OpAMD64VPSUBUSW128(v)
+ return rewriteValue_OpAMD64VPSUBUSW128(v)
case ssaop.OpAMD64VPSUBUSW256:
- return rewriteValueAMD64_OpAMD64VPSUBUSW256(v)
+ return rewriteValue_OpAMD64VPSUBUSW256(v)
case ssaop.OpAMD64VPSUBUSWMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBUSWMasked128(v)
+ return rewriteValue_OpAMD64VPSUBUSWMasked128(v)
case ssaop.OpAMD64VPSUBUSWMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBUSWMasked256(v)
+ return rewriteValue_OpAMD64VPSUBUSWMasked256(v)
case ssaop.OpAMD64VPSUBW128:
- return rewriteValueAMD64_OpAMD64VPSUBW128(v)
+ return rewriteValue_OpAMD64VPSUBW128(v)
case ssaop.OpAMD64VPSUBW256:
- return rewriteValueAMD64_OpAMD64VPSUBW256(v)
+ return rewriteValue_OpAMD64VPSUBW256(v)
case ssaop.OpAMD64VPSUBWMasked128:
- return rewriteValueAMD64_OpAMD64VPSUBWMasked128(v)
+ return rewriteValue_OpAMD64VPSUBWMasked128(v)
case ssaop.OpAMD64VPSUBWMasked256:
- return rewriteValueAMD64_OpAMD64VPSUBWMasked256(v)
+ return rewriteValue_OpAMD64VPSUBWMasked256(v)
case ssaop.OpAMD64VPTERNLOGD128:
- return rewriteValueAMD64_OpAMD64VPTERNLOGD128(v)
+ return rewriteValue_OpAMD64VPTERNLOGD128(v)
case ssaop.OpAMD64VPTERNLOGD256:
- return rewriteValueAMD64_OpAMD64VPTERNLOGD256(v)
+ return rewriteValue_OpAMD64VPTERNLOGD256(v)
case ssaop.OpAMD64VPTERNLOGD512:
- return rewriteValueAMD64_OpAMD64VPTERNLOGD512(v)
+ return rewriteValue_OpAMD64VPTERNLOGD512(v)
case ssaop.OpAMD64VPTERNLOGQ128:
- return rewriteValueAMD64_OpAMD64VPTERNLOGQ128(v)
+ return rewriteValue_OpAMD64VPTERNLOGQ128(v)
case ssaop.OpAMD64VPTERNLOGQ256:
- return rewriteValueAMD64_OpAMD64VPTERNLOGQ256(v)
+ return rewriteValue_OpAMD64VPTERNLOGQ256(v)
case ssaop.OpAMD64VPTERNLOGQ512:
- return rewriteValueAMD64_OpAMD64VPTERNLOGQ512(v)
+ return rewriteValue_OpAMD64VPTERNLOGQ512(v)
case ssaop.OpAMD64VPUNPCKHDQ128:
- return rewriteValueAMD64_OpAMD64VPUNPCKHDQ128(v)
+ return rewriteValue_OpAMD64VPUNPCKHDQ128(v)
case ssaop.OpAMD64VPUNPCKHDQ256:
- return rewriteValueAMD64_OpAMD64VPUNPCKHDQ256(v)
+ return rewriteValue_OpAMD64VPUNPCKHDQ256(v)
case ssaop.OpAMD64VPUNPCKHDQ512:
- return rewriteValueAMD64_OpAMD64VPUNPCKHDQ512(v)
+ return rewriteValue_OpAMD64VPUNPCKHDQ512(v)
case ssaop.OpAMD64VPUNPCKHQDQ128:
- return rewriteValueAMD64_OpAMD64VPUNPCKHQDQ128(v)
+ return rewriteValue_OpAMD64VPUNPCKHQDQ128(v)
case ssaop.OpAMD64VPUNPCKHQDQ256:
- return rewriteValueAMD64_OpAMD64VPUNPCKHQDQ256(v)
+ return rewriteValue_OpAMD64VPUNPCKHQDQ256(v)
case ssaop.OpAMD64VPUNPCKHQDQ512:
- return rewriteValueAMD64_OpAMD64VPUNPCKHQDQ512(v)
+ return rewriteValue_OpAMD64VPUNPCKHQDQ512(v)
case ssaop.OpAMD64VPUNPCKHWD128:
- return rewriteValueAMD64_OpAMD64VPUNPCKHWD128(v)
+ return rewriteValue_OpAMD64VPUNPCKHWD128(v)
case ssaop.OpAMD64VPUNPCKHWD256:
- return rewriteValueAMD64_OpAMD64VPUNPCKHWD256(v)
+ return rewriteValue_OpAMD64VPUNPCKHWD256(v)
case ssaop.OpAMD64VPUNPCKLDQ128:
- return rewriteValueAMD64_OpAMD64VPUNPCKLDQ128(v)
+ return rewriteValue_OpAMD64VPUNPCKLDQ128(v)
case ssaop.OpAMD64VPUNPCKLDQ256:
- return rewriteValueAMD64_OpAMD64VPUNPCKLDQ256(v)
+ return rewriteValue_OpAMD64VPUNPCKLDQ256(v)
case ssaop.OpAMD64VPUNPCKLDQ512:
- return rewriteValueAMD64_OpAMD64VPUNPCKLDQ512(v)
+ return rewriteValue_OpAMD64VPUNPCKLDQ512(v)
case ssaop.OpAMD64VPUNPCKLQDQ128:
- return rewriteValueAMD64_OpAMD64VPUNPCKLQDQ128(v)
+ return rewriteValue_OpAMD64VPUNPCKLQDQ128(v)
case ssaop.OpAMD64VPUNPCKLQDQ256:
- return rewriteValueAMD64_OpAMD64VPUNPCKLQDQ256(v)
+ return rewriteValue_OpAMD64VPUNPCKLQDQ256(v)
case ssaop.OpAMD64VPUNPCKLQDQ512:
- return rewriteValueAMD64_OpAMD64VPUNPCKLQDQ512(v)
+ return rewriteValue_OpAMD64VPUNPCKLQDQ512(v)
case ssaop.OpAMD64VPUNPCKLWD128:
- return rewriteValueAMD64_OpAMD64VPUNPCKLWD128(v)
+ return rewriteValue_OpAMD64VPUNPCKLWD128(v)
case ssaop.OpAMD64VPUNPCKLWD256:
- return rewriteValueAMD64_OpAMD64VPUNPCKLWD256(v)
+ return rewriteValue_OpAMD64VPUNPCKLWD256(v)
case ssaop.OpAMD64VPXOR128:
- return rewriteValueAMD64_OpAMD64VPXOR128(v)
+ return rewriteValue_OpAMD64VPXOR128(v)
case ssaop.OpAMD64VPXOR256:
- return rewriteValueAMD64_OpAMD64VPXOR256(v)
+ return rewriteValue_OpAMD64VPXOR256(v)
case ssaop.OpAMD64VPXORD512:
- return rewriteValueAMD64_OpAMD64VPXORD512(v)
+ return rewriteValue_OpAMD64VPXORD512(v)
case ssaop.OpAMD64VPXORDMasked128:
- return rewriteValueAMD64_OpAMD64VPXORDMasked128(v)
+ return rewriteValue_OpAMD64VPXORDMasked128(v)
case ssaop.OpAMD64VPXORDMasked256:
- return rewriteValueAMD64_OpAMD64VPXORDMasked256(v)
+ return rewriteValue_OpAMD64VPXORDMasked256(v)
case ssaop.OpAMD64VPXORDMasked512:
- return rewriteValueAMD64_OpAMD64VPXORDMasked512(v)
+ return rewriteValue_OpAMD64VPXORDMasked512(v)
case ssaop.OpAMD64VPXORQ512:
- return rewriteValueAMD64_OpAMD64VPXORQ512(v)
+ return rewriteValue_OpAMD64VPXORQ512(v)
case ssaop.OpAMD64VPXORQMasked128:
- return rewriteValueAMD64_OpAMD64VPXORQMasked128(v)
+ return rewriteValue_OpAMD64VPXORQMasked128(v)
case ssaop.OpAMD64VPXORQMasked256:
- return rewriteValueAMD64_OpAMD64VPXORQMasked256(v)
+ return rewriteValue_OpAMD64VPXORQMasked256(v)
case ssaop.OpAMD64VPXORQMasked512:
- return rewriteValueAMD64_OpAMD64VPXORQMasked512(v)
+ return rewriteValue_OpAMD64VPXORQMasked512(v)
case ssaop.OpAMD64VRCP14PD128:
- return rewriteValueAMD64_OpAMD64VRCP14PD128(v)
+ return rewriteValue_OpAMD64VRCP14PD128(v)
case ssaop.OpAMD64VRCP14PD256:
- return rewriteValueAMD64_OpAMD64VRCP14PD256(v)
+ return rewriteValue_OpAMD64VRCP14PD256(v)
case ssaop.OpAMD64VRCP14PD512:
- return rewriteValueAMD64_OpAMD64VRCP14PD512(v)
+ return rewriteValue_OpAMD64VRCP14PD512(v)
case ssaop.OpAMD64VRCP14PDMasked128:
- return rewriteValueAMD64_OpAMD64VRCP14PDMasked128(v)
+ return rewriteValue_OpAMD64VRCP14PDMasked128(v)
case ssaop.OpAMD64VRCP14PDMasked256:
- return rewriteValueAMD64_OpAMD64VRCP14PDMasked256(v)
+ return rewriteValue_OpAMD64VRCP14PDMasked256(v)
case ssaop.OpAMD64VRCP14PDMasked512:
- return rewriteValueAMD64_OpAMD64VRCP14PDMasked512(v)
+ return rewriteValue_OpAMD64VRCP14PDMasked512(v)
case ssaop.OpAMD64VRCP14PS512:
- return rewriteValueAMD64_OpAMD64VRCP14PS512(v)
+ return rewriteValue_OpAMD64VRCP14PS512(v)
case ssaop.OpAMD64VRCP14PSMasked128:
- return rewriteValueAMD64_OpAMD64VRCP14PSMasked128(v)
+ return rewriteValue_OpAMD64VRCP14PSMasked128(v)
case ssaop.OpAMD64VRCP14PSMasked256:
- return rewriteValueAMD64_OpAMD64VRCP14PSMasked256(v)
+ return rewriteValue_OpAMD64VRCP14PSMasked256(v)
case ssaop.OpAMD64VRCP14PSMasked512:
- return rewriteValueAMD64_OpAMD64VRCP14PSMasked512(v)
+ return rewriteValue_OpAMD64VRCP14PSMasked512(v)
case ssaop.OpAMD64VRCPPS128:
- return rewriteValueAMD64_OpAMD64VRCPPS128(v)
+ return rewriteValue_OpAMD64VRCPPS128(v)
case ssaop.OpAMD64VRCPPS256:
- return rewriteValueAMD64_OpAMD64VRCPPS256(v)
+ return rewriteValue_OpAMD64VRCPPS256(v)
case ssaop.OpAMD64VREDUCEPD128:
- return rewriteValueAMD64_OpAMD64VREDUCEPD128(v)
+ return rewriteValue_OpAMD64VREDUCEPD128(v)
case ssaop.OpAMD64VREDUCEPD256:
- return rewriteValueAMD64_OpAMD64VREDUCEPD256(v)
+ return rewriteValue_OpAMD64VREDUCEPD256(v)
case ssaop.OpAMD64VREDUCEPD512:
- return rewriteValueAMD64_OpAMD64VREDUCEPD512(v)
+ return rewriteValue_OpAMD64VREDUCEPD512(v)
case ssaop.OpAMD64VREDUCEPDMasked128:
- return rewriteValueAMD64_OpAMD64VREDUCEPDMasked128(v)
+ return rewriteValue_OpAMD64VREDUCEPDMasked128(v)
case ssaop.OpAMD64VREDUCEPDMasked256:
- return rewriteValueAMD64_OpAMD64VREDUCEPDMasked256(v)
+ return rewriteValue_OpAMD64VREDUCEPDMasked256(v)
case ssaop.OpAMD64VREDUCEPDMasked512:
- return rewriteValueAMD64_OpAMD64VREDUCEPDMasked512(v)
+ return rewriteValue_OpAMD64VREDUCEPDMasked512(v)
case ssaop.OpAMD64VREDUCEPS128:
- return rewriteValueAMD64_OpAMD64VREDUCEPS128(v)
+ return rewriteValue_OpAMD64VREDUCEPS128(v)
case ssaop.OpAMD64VREDUCEPS256:
- return rewriteValueAMD64_OpAMD64VREDUCEPS256(v)
+ return rewriteValue_OpAMD64VREDUCEPS256(v)
case ssaop.OpAMD64VREDUCEPS512:
- return rewriteValueAMD64_OpAMD64VREDUCEPS512(v)
+ return rewriteValue_OpAMD64VREDUCEPS512(v)
case ssaop.OpAMD64VREDUCEPSMasked128:
- return rewriteValueAMD64_OpAMD64VREDUCEPSMasked128(v)
+ return rewriteValue_OpAMD64VREDUCEPSMasked128(v)
case ssaop.OpAMD64VREDUCEPSMasked256:
- return rewriteValueAMD64_OpAMD64VREDUCEPSMasked256(v)
+ return rewriteValue_OpAMD64VREDUCEPSMasked256(v)
case ssaop.OpAMD64VREDUCEPSMasked512:
- return rewriteValueAMD64_OpAMD64VREDUCEPSMasked512(v)
+ return rewriteValue_OpAMD64VREDUCEPSMasked512(v)
case ssaop.OpAMD64VRNDSCALEPD128:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPD128(v)
+ return rewriteValue_OpAMD64VRNDSCALEPD128(v)
case ssaop.OpAMD64VRNDSCALEPD256:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPD256(v)
+ return rewriteValue_OpAMD64VRNDSCALEPD256(v)
case ssaop.OpAMD64VRNDSCALEPD512:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPD512(v)
+ return rewriteValue_OpAMD64VRNDSCALEPD512(v)
case ssaop.OpAMD64VRNDSCALEPDMasked128:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked128(v)
+ return rewriteValue_OpAMD64VRNDSCALEPDMasked128(v)
case ssaop.OpAMD64VRNDSCALEPDMasked256:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked256(v)
+ return rewriteValue_OpAMD64VRNDSCALEPDMasked256(v)
case ssaop.OpAMD64VRNDSCALEPDMasked512:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked512(v)
+ return rewriteValue_OpAMD64VRNDSCALEPDMasked512(v)
case ssaop.OpAMD64VRNDSCALEPS128:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPS128(v)
+ return rewriteValue_OpAMD64VRNDSCALEPS128(v)
case ssaop.OpAMD64VRNDSCALEPS256:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPS256(v)
+ return rewriteValue_OpAMD64VRNDSCALEPS256(v)
case ssaop.OpAMD64VRNDSCALEPS512:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPS512(v)
+ return rewriteValue_OpAMD64VRNDSCALEPS512(v)
case ssaop.OpAMD64VRNDSCALEPSMasked128:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked128(v)
+ return rewriteValue_OpAMD64VRNDSCALEPSMasked128(v)
case ssaop.OpAMD64VRNDSCALEPSMasked256:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked256(v)
+ return rewriteValue_OpAMD64VRNDSCALEPSMasked256(v)
case ssaop.OpAMD64VRNDSCALEPSMasked512:
- return rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked512(v)
+ return rewriteValue_OpAMD64VRNDSCALEPSMasked512(v)
case ssaop.OpAMD64VROUNDPD128:
- return rewriteValueAMD64_OpAMD64VROUNDPD128(v)
+ return rewriteValue_OpAMD64VROUNDPD128(v)
case ssaop.OpAMD64VROUNDPD256:
- return rewriteValueAMD64_OpAMD64VROUNDPD256(v)
+ return rewriteValue_OpAMD64VROUNDPD256(v)
case ssaop.OpAMD64VROUNDPS128:
- return rewriteValueAMD64_OpAMD64VROUNDPS128(v)
+ return rewriteValue_OpAMD64VROUNDPS128(v)
case ssaop.OpAMD64VROUNDPS256:
- return rewriteValueAMD64_OpAMD64VROUNDPS256(v)
+ return rewriteValue_OpAMD64VROUNDPS256(v)
case ssaop.OpAMD64VRSQRT14PD128:
- return rewriteValueAMD64_OpAMD64VRSQRT14PD128(v)
+ return rewriteValue_OpAMD64VRSQRT14PD128(v)
case ssaop.OpAMD64VRSQRT14PD256:
- return rewriteValueAMD64_OpAMD64VRSQRT14PD256(v)
+ return rewriteValue_OpAMD64VRSQRT14PD256(v)
case ssaop.OpAMD64VRSQRT14PD512:
- return rewriteValueAMD64_OpAMD64VRSQRT14PD512(v)
+ return rewriteValue_OpAMD64VRSQRT14PD512(v)
case ssaop.OpAMD64VRSQRT14PDMasked128:
- return rewriteValueAMD64_OpAMD64VRSQRT14PDMasked128(v)
+ return rewriteValue_OpAMD64VRSQRT14PDMasked128(v)
case ssaop.OpAMD64VRSQRT14PDMasked256:
- return rewriteValueAMD64_OpAMD64VRSQRT14PDMasked256(v)
+ return rewriteValue_OpAMD64VRSQRT14PDMasked256(v)
case ssaop.OpAMD64VRSQRT14PDMasked512:
- return rewriteValueAMD64_OpAMD64VRSQRT14PDMasked512(v)
+ return rewriteValue_OpAMD64VRSQRT14PDMasked512(v)
case ssaop.OpAMD64VRSQRT14PS512:
- return rewriteValueAMD64_OpAMD64VRSQRT14PS512(v)
+ return rewriteValue_OpAMD64VRSQRT14PS512(v)
case ssaop.OpAMD64VRSQRT14PSMasked128:
- return rewriteValueAMD64_OpAMD64VRSQRT14PSMasked128(v)
+ return rewriteValue_OpAMD64VRSQRT14PSMasked128(v)
case ssaop.OpAMD64VRSQRT14PSMasked256:
- return rewriteValueAMD64_OpAMD64VRSQRT14PSMasked256(v)
+ return rewriteValue_OpAMD64VRSQRT14PSMasked256(v)
case ssaop.OpAMD64VRSQRT14PSMasked512:
- return rewriteValueAMD64_OpAMD64VRSQRT14PSMasked512(v)
+ return rewriteValue_OpAMD64VRSQRT14PSMasked512(v)
case ssaop.OpAMD64VRSQRTPS128:
- return rewriteValueAMD64_OpAMD64VRSQRTPS128(v)
+ return rewriteValue_OpAMD64VRSQRTPS128(v)
case ssaop.OpAMD64VRSQRTPS256:
- return rewriteValueAMD64_OpAMD64VRSQRTPS256(v)
+ return rewriteValue_OpAMD64VRSQRTPS256(v)
case ssaop.OpAMD64VSCALEFPD128:
- return rewriteValueAMD64_OpAMD64VSCALEFPD128(v)
+ return rewriteValue_OpAMD64VSCALEFPD128(v)
case ssaop.OpAMD64VSCALEFPD256:
- return rewriteValueAMD64_OpAMD64VSCALEFPD256(v)
+ return rewriteValue_OpAMD64VSCALEFPD256(v)
case ssaop.OpAMD64VSCALEFPD512:
- return rewriteValueAMD64_OpAMD64VSCALEFPD512(v)
+ return rewriteValue_OpAMD64VSCALEFPD512(v)
case ssaop.OpAMD64VSCALEFPDMasked128:
- return rewriteValueAMD64_OpAMD64VSCALEFPDMasked128(v)
+ return rewriteValue_OpAMD64VSCALEFPDMasked128(v)
case ssaop.OpAMD64VSCALEFPDMasked256:
- return rewriteValueAMD64_OpAMD64VSCALEFPDMasked256(v)
+ return rewriteValue_OpAMD64VSCALEFPDMasked256(v)
case ssaop.OpAMD64VSCALEFPDMasked512:
- return rewriteValueAMD64_OpAMD64VSCALEFPDMasked512(v)
+ return rewriteValue_OpAMD64VSCALEFPDMasked512(v)
case ssaop.OpAMD64VSCALEFPS128:
- return rewriteValueAMD64_OpAMD64VSCALEFPS128(v)
+ return rewriteValue_OpAMD64VSCALEFPS128(v)
case ssaop.OpAMD64VSCALEFPS256:
- return rewriteValueAMD64_OpAMD64VSCALEFPS256(v)
+ return rewriteValue_OpAMD64VSCALEFPS256(v)
case ssaop.OpAMD64VSCALEFPS512:
- return rewriteValueAMD64_OpAMD64VSCALEFPS512(v)
+ return rewriteValue_OpAMD64VSCALEFPS512(v)
case ssaop.OpAMD64VSCALEFPSMasked128:
- return rewriteValueAMD64_OpAMD64VSCALEFPSMasked128(v)
+ return rewriteValue_OpAMD64VSCALEFPSMasked128(v)
case ssaop.OpAMD64VSCALEFPSMasked256:
- return rewriteValueAMD64_OpAMD64VSCALEFPSMasked256(v)
+ return rewriteValue_OpAMD64VSCALEFPSMasked256(v)
case ssaop.OpAMD64VSCALEFPSMasked512:
- return rewriteValueAMD64_OpAMD64VSCALEFPSMasked512(v)
+ return rewriteValue_OpAMD64VSCALEFPSMasked512(v)
case ssaop.OpAMD64VSHUFPD128:
- return rewriteValueAMD64_OpAMD64VSHUFPD128(v)
+ return rewriteValue_OpAMD64VSHUFPD128(v)
case ssaop.OpAMD64VSHUFPD256:
- return rewriteValueAMD64_OpAMD64VSHUFPD256(v)
+ return rewriteValue_OpAMD64VSHUFPD256(v)
case ssaop.OpAMD64VSHUFPD512:
- return rewriteValueAMD64_OpAMD64VSHUFPD512(v)
+ return rewriteValue_OpAMD64VSHUFPD512(v)
case ssaop.OpAMD64VSHUFPS128:
- return rewriteValueAMD64_OpAMD64VSHUFPS128(v)
+ return rewriteValue_OpAMD64VSHUFPS128(v)
case ssaop.OpAMD64VSHUFPS256:
- return rewriteValueAMD64_OpAMD64VSHUFPS256(v)
+ return rewriteValue_OpAMD64VSHUFPS256(v)
case ssaop.OpAMD64VSHUFPS512:
- return rewriteValueAMD64_OpAMD64VSHUFPS512(v)
+ return rewriteValue_OpAMD64VSHUFPS512(v)
case ssaop.OpAMD64VSQRTPD128:
- return rewriteValueAMD64_OpAMD64VSQRTPD128(v)
+ return rewriteValue_OpAMD64VSQRTPD128(v)
case ssaop.OpAMD64VSQRTPD256:
- return rewriteValueAMD64_OpAMD64VSQRTPD256(v)
+ return rewriteValue_OpAMD64VSQRTPD256(v)
case ssaop.OpAMD64VSQRTPD512:
- return rewriteValueAMD64_OpAMD64VSQRTPD512(v)
+ return rewriteValue_OpAMD64VSQRTPD512(v)
case ssaop.OpAMD64VSQRTPDMasked128:
- return rewriteValueAMD64_OpAMD64VSQRTPDMasked128(v)
+ return rewriteValue_OpAMD64VSQRTPDMasked128(v)
case ssaop.OpAMD64VSQRTPDMasked256:
- return rewriteValueAMD64_OpAMD64VSQRTPDMasked256(v)
+ return rewriteValue_OpAMD64VSQRTPDMasked256(v)
case ssaop.OpAMD64VSQRTPDMasked512:
- return rewriteValueAMD64_OpAMD64VSQRTPDMasked512(v)
+ return rewriteValue_OpAMD64VSQRTPDMasked512(v)
case ssaop.OpAMD64VSQRTPS128:
- return rewriteValueAMD64_OpAMD64VSQRTPS128(v)
+ return rewriteValue_OpAMD64VSQRTPS128(v)
case ssaop.OpAMD64VSQRTPS256:
- return rewriteValueAMD64_OpAMD64VSQRTPS256(v)
+ return rewriteValue_OpAMD64VSQRTPS256(v)
case ssaop.OpAMD64VSQRTPS512:
- return rewriteValueAMD64_OpAMD64VSQRTPS512(v)
+ return rewriteValue_OpAMD64VSQRTPS512(v)
case ssaop.OpAMD64VSQRTPSMasked128:
- return rewriteValueAMD64_OpAMD64VSQRTPSMasked128(v)
+ return rewriteValue_OpAMD64VSQRTPSMasked128(v)
case ssaop.OpAMD64VSQRTPSMasked256:
- return rewriteValueAMD64_OpAMD64VSQRTPSMasked256(v)
+ return rewriteValue_OpAMD64VSQRTPSMasked256(v)
case ssaop.OpAMD64VSQRTPSMasked512:
- return rewriteValueAMD64_OpAMD64VSQRTPSMasked512(v)
+ return rewriteValue_OpAMD64VSQRTPSMasked512(v)
case ssaop.OpAMD64VSUBPD128:
- return rewriteValueAMD64_OpAMD64VSUBPD128(v)
+ return rewriteValue_OpAMD64VSUBPD128(v)
case ssaop.OpAMD64VSUBPD256:
- return rewriteValueAMD64_OpAMD64VSUBPD256(v)
+ return rewriteValue_OpAMD64VSUBPD256(v)
case ssaop.OpAMD64VSUBPD512:
- return rewriteValueAMD64_OpAMD64VSUBPD512(v)
+ return rewriteValue_OpAMD64VSUBPD512(v)
case ssaop.OpAMD64VSUBPDMasked128:
- return rewriteValueAMD64_OpAMD64VSUBPDMasked128(v)
+ return rewriteValue_OpAMD64VSUBPDMasked128(v)
case ssaop.OpAMD64VSUBPDMasked256:
- return rewriteValueAMD64_OpAMD64VSUBPDMasked256(v)
+ return rewriteValue_OpAMD64VSUBPDMasked256(v)
case ssaop.OpAMD64VSUBPDMasked512:
- return rewriteValueAMD64_OpAMD64VSUBPDMasked512(v)
+ return rewriteValue_OpAMD64VSUBPDMasked512(v)
case ssaop.OpAMD64VSUBPS128:
- return rewriteValueAMD64_OpAMD64VSUBPS128(v)
+ return rewriteValue_OpAMD64VSUBPS128(v)
case ssaop.OpAMD64VSUBPS256:
- return rewriteValueAMD64_OpAMD64VSUBPS256(v)
+ return rewriteValue_OpAMD64VSUBPS256(v)
case ssaop.OpAMD64VSUBPS512:
- return rewriteValueAMD64_OpAMD64VSUBPS512(v)
+ return rewriteValue_OpAMD64VSUBPS512(v)
case ssaop.OpAMD64VSUBPSMasked128:
- return rewriteValueAMD64_OpAMD64VSUBPSMasked128(v)
+ return rewriteValue_OpAMD64VSUBPSMasked128(v)
case ssaop.OpAMD64VSUBPSMasked256:
- return rewriteValueAMD64_OpAMD64VSUBPSMasked256(v)
+ return rewriteValue_OpAMD64VSUBPSMasked256(v)
case ssaop.OpAMD64VSUBPSMasked512:
- return rewriteValueAMD64_OpAMD64VSUBPSMasked512(v)
+ return rewriteValue_OpAMD64VSUBPSMasked512(v)
case ssaop.OpAMD64XADDLlock:
- return rewriteValueAMD64_OpAMD64XADDLlock(v)
+ return rewriteValue_OpAMD64XADDLlock(v)
case ssaop.OpAMD64XADDQlock:
- return rewriteValueAMD64_OpAMD64XADDQlock(v)
+ return rewriteValue_OpAMD64XADDQlock(v)
case ssaop.OpAMD64XCHGL:
- return rewriteValueAMD64_OpAMD64XCHGL(v)
+ return rewriteValue_OpAMD64XCHGL(v)
case ssaop.OpAMD64XCHGQ:
- return rewriteValueAMD64_OpAMD64XCHGQ(v)
+ return rewriteValue_OpAMD64XCHGQ(v)
case ssaop.OpAMD64XORBconstmodify:
- return rewriteValueAMD64_OpAMD64XORBconstmodify(v)
+ return rewriteValue_OpAMD64XORBconstmodify(v)
case ssaop.OpAMD64XORL:
- return rewriteValueAMD64_OpAMD64XORL(v)
+ return rewriteValue_OpAMD64XORL(v)
case ssaop.OpAMD64XORLconst:
- return rewriteValueAMD64_OpAMD64XORLconst(v)
+ return rewriteValue_OpAMD64XORLconst(v)
case ssaop.OpAMD64XORLconstmodify:
- return rewriteValueAMD64_OpAMD64XORLconstmodify(v)
+ return rewriteValue_OpAMD64XORLconstmodify(v)
case ssaop.OpAMD64XORLload:
- return rewriteValueAMD64_OpAMD64XORLload(v)
+ return rewriteValue_OpAMD64XORLload(v)
case ssaop.OpAMD64XORLmodify:
- return rewriteValueAMD64_OpAMD64XORLmodify(v)
+ return rewriteValue_OpAMD64XORLmodify(v)
case ssaop.OpAMD64XORQ:
- return rewriteValueAMD64_OpAMD64XORQ(v)
+ return rewriteValue_OpAMD64XORQ(v)
case ssaop.OpAMD64XORQconst:
- return rewriteValueAMD64_OpAMD64XORQconst(v)
+ return rewriteValue_OpAMD64XORQconst(v)
case ssaop.OpAMD64XORQconstmodify:
- return rewriteValueAMD64_OpAMD64XORQconstmodify(v)
+ return rewriteValue_OpAMD64XORQconstmodify(v)
case ssaop.OpAMD64XORQload:
- return rewriteValueAMD64_OpAMD64XORQload(v)
+ return rewriteValue_OpAMD64XORQload(v)
case ssaop.OpAMD64XORQmodify:
- return rewriteValueAMD64_OpAMD64XORQmodify(v)
+ return rewriteValue_OpAMD64XORQmodify(v)
case ssaop.OpAMD64XORWconstmodify:
- return rewriteValueAMD64_OpAMD64XORWconstmodify(v)
+ return rewriteValue_OpAMD64XORWconstmodify(v)
case ssaop.OpAbsInt16x16:
v.Op = ssaop.OpAMD64VPABSW256
return true
@@ -3295,7 +3295,7 @@
v.Op = ssaop.OpAMD64VPADDB512
return true
case ssaop.OpAddr:
- return rewriteValueAMD64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpAMD64ANDL
return true
@@ -3456,51 +3456,51 @@
v.Op = ssaop.OpAMD64VPANDD512
return true
case ssaop.OpAtomicAdd32:
- return rewriteValueAMD64_OpAtomicAdd32(v)
+ return rewriteValue_OpAtomicAdd32(v)
case ssaop.OpAtomicAdd64:
- return rewriteValueAMD64_OpAtomicAdd64(v)
+ return rewriteValue_OpAtomicAdd64(v)
case ssaop.OpAtomicAnd32:
- return rewriteValueAMD64_OpAtomicAnd32(v)
+ return rewriteValue_OpAtomicAnd32(v)
case ssaop.OpAtomicAnd32value:
- return rewriteValueAMD64_OpAtomicAnd32value(v)
+ return rewriteValue_OpAtomicAnd32value(v)
case ssaop.OpAtomicAnd64value:
- return rewriteValueAMD64_OpAtomicAnd64value(v)
+ return rewriteValue_OpAtomicAnd64value(v)
case ssaop.OpAtomicAnd8:
- return rewriteValueAMD64_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValueAMD64_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap64:
- return rewriteValueAMD64_OpAtomicCompareAndSwap64(v)
+ return rewriteValue_OpAtomicCompareAndSwap64(v)
case ssaop.OpAtomicExchange32:
- return rewriteValueAMD64_OpAtomicExchange32(v)
+ return rewriteValue_OpAtomicExchange32(v)
case ssaop.OpAtomicExchange64:
- return rewriteValueAMD64_OpAtomicExchange64(v)
+ return rewriteValue_OpAtomicExchange64(v)
case ssaop.OpAtomicExchange8:
- return rewriteValueAMD64_OpAtomicExchange8(v)
+ return rewriteValue_OpAtomicExchange8(v)
case ssaop.OpAtomicLoad32:
- return rewriteValueAMD64_OpAtomicLoad32(v)
+ return rewriteValue_OpAtomicLoad32(v)
case ssaop.OpAtomicLoad64:
- return rewriteValueAMD64_OpAtomicLoad64(v)
+ return rewriteValue_OpAtomicLoad64(v)
case ssaop.OpAtomicLoad8:
- return rewriteValueAMD64_OpAtomicLoad8(v)
+ return rewriteValue_OpAtomicLoad8(v)
case ssaop.OpAtomicLoadPtr:
- return rewriteValueAMD64_OpAtomicLoadPtr(v)
+ return rewriteValue_OpAtomicLoadPtr(v)
case ssaop.OpAtomicOr32:
- return rewriteValueAMD64_OpAtomicOr32(v)
+ return rewriteValue_OpAtomicOr32(v)
case ssaop.OpAtomicOr32value:
- return rewriteValueAMD64_OpAtomicOr32value(v)
+ return rewriteValue_OpAtomicOr32value(v)
case ssaop.OpAtomicOr64value:
- return rewriteValueAMD64_OpAtomicOr64value(v)
+ return rewriteValue_OpAtomicOr64value(v)
case ssaop.OpAtomicOr8:
- return rewriteValueAMD64_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
- return rewriteValueAMD64_OpAtomicStore32(v)
+ return rewriteValue_OpAtomicStore32(v)
case ssaop.OpAtomicStore64:
- return rewriteValueAMD64_OpAtomicStore64(v)
+ return rewriteValue_OpAtomicStore64(v)
case ssaop.OpAtomicStore8:
- return rewriteValueAMD64_OpAtomicStore8(v)
+ return rewriteValue_OpAtomicStore8(v)
case ssaop.OpAtomicStorePtrNoWB:
- return rewriteValueAMD64_OpAtomicStorePtrNoWB(v)
+ return rewriteValue_OpAtomicStorePtrNoWB(v)
case ssaop.OpAverageUint16x16:
v.Op = ssaop.OpAMD64VPAVGW256
return true
@@ -3523,15 +3523,15 @@
v.Op = ssaop.OpAMD64AVGQU
return true
case ssaop.OpBitLen16:
- return rewriteValueAMD64_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueAMD64_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueAMD64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueAMD64_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBswap16:
- return rewriteValueAMD64_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
v.Op = ssaop.OpAMD64BSWAPL
return true
@@ -3539,39 +3539,39 @@
v.Op = ssaop.OpAMD64BSWAPQ
return true
case ssaop.OpCeil:
- return rewriteValueAMD64_OpCeil(v)
+ return rewriteValue_OpCeil(v)
case ssaop.OpCeilFloat32x4:
- return rewriteValueAMD64_OpCeilFloat32x4(v)
+ return rewriteValue_OpCeilFloat32x4(v)
case ssaop.OpCeilFloat32x8:
- return rewriteValueAMD64_OpCeilFloat32x8(v)
+ return rewriteValue_OpCeilFloat32x8(v)
case ssaop.OpCeilFloat64x2:
- return rewriteValueAMD64_OpCeilFloat64x2(v)
+ return rewriteValue_OpCeilFloat64x2(v)
case ssaop.OpCeilFloat64x4:
- return rewriteValueAMD64_OpCeilFloat64x4(v)
+ return rewriteValue_OpCeilFloat64x4(v)
case ssaop.OpCeilScaledFloat32x16:
- return rewriteValueAMD64_OpCeilScaledFloat32x16(v)
+ return rewriteValue_OpCeilScaledFloat32x16(v)
case ssaop.OpCeilScaledFloat32x4:
- return rewriteValueAMD64_OpCeilScaledFloat32x4(v)
+ return rewriteValue_OpCeilScaledFloat32x4(v)
case ssaop.OpCeilScaledFloat32x8:
- return rewriteValueAMD64_OpCeilScaledFloat32x8(v)
+ return rewriteValue_OpCeilScaledFloat32x8(v)
case ssaop.OpCeilScaledFloat64x2:
- return rewriteValueAMD64_OpCeilScaledFloat64x2(v)
+ return rewriteValue_OpCeilScaledFloat64x2(v)
case ssaop.OpCeilScaledFloat64x4:
- return rewriteValueAMD64_OpCeilScaledFloat64x4(v)
+ return rewriteValue_OpCeilScaledFloat64x4(v)
case ssaop.OpCeilScaledFloat64x8:
- return rewriteValueAMD64_OpCeilScaledFloat64x8(v)
+ return rewriteValue_OpCeilScaledFloat64x8(v)
case ssaop.OpCeilScaledResidueFloat32x16:
- return rewriteValueAMD64_OpCeilScaledResidueFloat32x16(v)
+ return rewriteValue_OpCeilScaledResidueFloat32x16(v)
case ssaop.OpCeilScaledResidueFloat32x4:
- return rewriteValueAMD64_OpCeilScaledResidueFloat32x4(v)
+ return rewriteValue_OpCeilScaledResidueFloat32x4(v)
case ssaop.OpCeilScaledResidueFloat32x8:
- return rewriteValueAMD64_OpCeilScaledResidueFloat32x8(v)
+ return rewriteValue_OpCeilScaledResidueFloat32x8(v)
case ssaop.OpCeilScaledResidueFloat64x2:
- return rewriteValueAMD64_OpCeilScaledResidueFloat64x2(v)
+ return rewriteValue_OpCeilScaledResidueFloat64x2(v)
case ssaop.OpCeilScaledResidueFloat64x4:
- return rewriteValueAMD64_OpCeilScaledResidueFloat64x4(v)
+ return rewriteValue_OpCeilScaledResidueFloat64x4(v)
case ssaop.OpCeilScaledResidueFloat64x8:
- return rewriteValueAMD64_OpCeilScaledResidueFloat64x8(v)
+ return rewriteValue_OpCeilScaledResidueFloat64x8(v)
case ssaop.OpClosureCall:
v.Op = ssaop.OpAMD64CALLclosure
return true
@@ -3588,65 +3588,65 @@
v.Op = ssaop.OpAMD64NOTL
return true
case ssaop.OpCompressFloat32x16:
- return rewriteValueAMD64_OpCompressFloat32x16(v)
+ return rewriteValue_OpCompressFloat32x16(v)
case ssaop.OpCompressFloat32x4:
- return rewriteValueAMD64_OpCompressFloat32x4(v)
+ return rewriteValue_OpCompressFloat32x4(v)
case ssaop.OpCompressFloat32x8:
- return rewriteValueAMD64_OpCompressFloat32x8(v)
+ return rewriteValue_OpCompressFloat32x8(v)
case ssaop.OpCompressFloat64x2:
- return rewriteValueAMD64_OpCompressFloat64x2(v)
+ return rewriteValue_OpCompressFloat64x2(v)
case ssaop.OpCompressFloat64x4:
- return rewriteValueAMD64_OpCompressFloat64x4(v)
+ return rewriteValue_OpCompressFloat64x4(v)
case ssaop.OpCompressFloat64x8:
- return rewriteValueAMD64_OpCompressFloat64x8(v)
+ return rewriteValue_OpCompressFloat64x8(v)
case ssaop.OpCompressInt16x16:
- return rewriteValueAMD64_OpCompressInt16x16(v)
+ return rewriteValue_OpCompressInt16x16(v)
case ssaop.OpCompressInt16x32:
- return rewriteValueAMD64_OpCompressInt16x32(v)
+ return rewriteValue_OpCompressInt16x32(v)
case ssaop.OpCompressInt16x8:
- return rewriteValueAMD64_OpCompressInt16x8(v)
+ return rewriteValue_OpCompressInt16x8(v)
case ssaop.OpCompressInt32x16:
- return rewriteValueAMD64_OpCompressInt32x16(v)
+ return rewriteValue_OpCompressInt32x16(v)
case ssaop.OpCompressInt32x4:
- return rewriteValueAMD64_OpCompressInt32x4(v)
+ return rewriteValue_OpCompressInt32x4(v)
case ssaop.OpCompressInt32x8:
- return rewriteValueAMD64_OpCompressInt32x8(v)
+ return rewriteValue_OpCompressInt32x8(v)
case ssaop.OpCompressInt64x2:
- return rewriteValueAMD64_OpCompressInt64x2(v)
+ return rewriteValue_OpCompressInt64x2(v)
case ssaop.OpCompressInt64x4:
- return rewriteValueAMD64_OpCompressInt64x4(v)
+ return rewriteValue_OpCompressInt64x4(v)
case ssaop.OpCompressInt64x8:
- return rewriteValueAMD64_OpCompressInt64x8(v)
+ return rewriteValue_OpCompressInt64x8(v)
case ssaop.OpCompressInt8x16:
- return rewriteValueAMD64_OpCompressInt8x16(v)
+ return rewriteValue_OpCompressInt8x16(v)
case ssaop.OpCompressInt8x32:
- return rewriteValueAMD64_OpCompressInt8x32(v)
+ return rewriteValue_OpCompressInt8x32(v)
case ssaop.OpCompressInt8x64:
- return rewriteValueAMD64_OpCompressInt8x64(v)
+ return rewriteValue_OpCompressInt8x64(v)
case ssaop.OpCompressUint16x16:
- return rewriteValueAMD64_OpCompressUint16x16(v)
+ return rewriteValue_OpCompressUint16x16(v)
case ssaop.OpCompressUint16x32:
- return rewriteValueAMD64_OpCompressUint16x32(v)
+ return rewriteValue_OpCompressUint16x32(v)
case ssaop.OpCompressUint16x8:
- return rewriteValueAMD64_OpCompressUint16x8(v)
+ return rewriteValue_OpCompressUint16x8(v)
case ssaop.OpCompressUint32x16:
- return rewriteValueAMD64_OpCompressUint32x16(v)
+ return rewriteValue_OpCompressUint32x16(v)
case ssaop.OpCompressUint32x4:
- return rewriteValueAMD64_OpCompressUint32x4(v)
+ return rewriteValue_OpCompressUint32x4(v)
case ssaop.OpCompressUint32x8:
- return rewriteValueAMD64_OpCompressUint32x8(v)
+ return rewriteValue_OpCompressUint32x8(v)
case ssaop.OpCompressUint64x2:
- return rewriteValueAMD64_OpCompressUint64x2(v)
+ return rewriteValue_OpCompressUint64x2(v)
case ssaop.OpCompressUint64x4:
- return rewriteValueAMD64_OpCompressUint64x4(v)
+ return rewriteValue_OpCompressUint64x4(v)
case ssaop.OpCompressUint64x8:
- return rewriteValueAMD64_OpCompressUint64x8(v)
+ return rewriteValue_OpCompressUint64x8(v)
case ssaop.OpCompressUint8x16:
- return rewriteValueAMD64_OpCompressUint8x16(v)
+ return rewriteValue_OpCompressUint8x16(v)
case ssaop.OpCompressUint8x32:
- return rewriteValueAMD64_OpCompressUint8x32(v)
+ return rewriteValue_OpCompressUint8x32(v)
case ssaop.OpCompressUint8x64:
- return rewriteValueAMD64_OpCompressUint8x64(v)
+ return rewriteValue_OpCompressUint8x64(v)
case ssaop.OpConcatAddPairsFloat32x4:
v.Op = ssaop.OpAMD64VHADDPS128
return true
@@ -3861,9 +3861,9 @@
v.Op = ssaop.OpAMD64VPHSUBD128
return true
case ssaop.OpCondSelect:
- return rewriteValueAMD64_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConst16:
- return rewriteValueAMD64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
v.Op = ssaop.OpAMD64MOVLconst
return true
@@ -3877,11 +3877,11 @@
v.Op = ssaop.OpAMD64MOVSDconst
return true
case ssaop.OpConst8:
- return rewriteValueAMD64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueAMD64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueAMD64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpConvertToFloat32Float64x2:
v.Op = ssaop.OpAMD64VCVTPD2PSX128
return true
@@ -4030,31 +4030,31 @@
v.Op = ssaop.OpAMD64VCVTTPD2UQQ512
return true
case ssaop.OpCtz16:
- return rewriteValueAMD64_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
- return rewriteValueAMD64_OpCtz16NonZero(v)
+ return rewriteValue_OpCtz16NonZero(v)
case ssaop.OpCtz32:
- return rewriteValueAMD64_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
- return rewriteValueAMD64_OpCtz32NonZero(v)
+ return rewriteValue_OpCtz32NonZero(v)
case ssaop.OpCtz64:
- return rewriteValueAMD64_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz64NonZero:
- return rewriteValueAMD64_OpCtz64NonZero(v)
+ return rewriteValue_OpCtz64NonZero(v)
case ssaop.OpCtz8:
- return rewriteValueAMD64_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
- return rewriteValueAMD64_OpCtz8NonZero(v)
+ return rewriteValue_OpCtz8NonZero(v)
case ssaop.OpCvt16toMask16x16:
- return rewriteValueAMD64_OpCvt16toMask16x16(v)
+ return rewriteValue_OpCvt16toMask16x16(v)
case ssaop.OpCvt16toMask32x16:
- return rewriteValueAMD64_OpCvt16toMask32x16(v)
+ return rewriteValue_OpCvt16toMask32x16(v)
case ssaop.OpCvt16toMask8x16:
- return rewriteValueAMD64_OpCvt16toMask8x16(v)
+ return rewriteValue_OpCvt16toMask8x16(v)
case ssaop.OpCvt32Fto32:
- return rewriteValueAMD64_OpCvt32Fto32(v)
+ return rewriteValue_OpCvt32Fto32(v)
case ssaop.OpCvt32Fto64:
- return rewriteValueAMD64_OpCvt32Fto64(v)
+ return rewriteValue_OpCvt32Fto64(v)
case ssaop.OpCvt32Fto64F:
v.Op = ssaop.OpAMD64CVTSS2SD
return true
@@ -4065,16 +4065,16 @@
v.Op = ssaop.OpAMD64CVTSL2SD
return true
case ssaop.OpCvt32toMask16x32:
- return rewriteValueAMD64_OpCvt32toMask16x32(v)
+ return rewriteValue_OpCvt32toMask16x32(v)
case ssaop.OpCvt32toMask8x32:
- return rewriteValueAMD64_OpCvt32toMask8x32(v)
+ return rewriteValue_OpCvt32toMask8x32(v)
case ssaop.OpCvt64Fto32:
- return rewriteValueAMD64_OpCvt64Fto32(v)
+ return rewriteValue_OpCvt64Fto32(v)
case ssaop.OpCvt64Fto32F:
v.Op = ssaop.OpAMD64CVTSD2SS
return true
case ssaop.OpCvt64Fto64:
- return rewriteValueAMD64_OpCvt64Fto64(v)
+ return rewriteValue_OpCvt64Fto64(v)
case ssaop.OpCvt64to32F:
v.Op = ssaop.OpAMD64CVTSQ2SS
return true
@@ -4082,30 +4082,30 @@
v.Op = ssaop.OpAMD64CVTSQ2SD
return true
case ssaop.OpCvt64toMask8x64:
- return rewriteValueAMD64_OpCvt64toMask8x64(v)
+ return rewriteValue_OpCvt64toMask8x64(v)
case ssaop.OpCvt8toMask16x8:
- return rewriteValueAMD64_OpCvt8toMask16x8(v)
+ return rewriteValue_OpCvt8toMask16x8(v)
case ssaop.OpCvt8toMask32x4:
- return rewriteValueAMD64_OpCvt8toMask32x4(v)
+ return rewriteValue_OpCvt8toMask32x4(v)
case ssaop.OpCvt8toMask32x8:
- return rewriteValueAMD64_OpCvt8toMask32x8(v)
+ return rewriteValue_OpCvt8toMask32x8(v)
case ssaop.OpCvt8toMask64x2:
- return rewriteValueAMD64_OpCvt8toMask64x2(v)
+ return rewriteValue_OpCvt8toMask64x2(v)
case ssaop.OpCvt8toMask64x4:
- return rewriteValueAMD64_OpCvt8toMask64x4(v)
+ return rewriteValue_OpCvt8toMask64x4(v)
case ssaop.OpCvt8toMask64x8:
- return rewriteValueAMD64_OpCvt8toMask64x8(v)
+ return rewriteValue_OpCvt8toMask64x8(v)
case ssaop.OpCvtBoolToUint8:
v.Op = ssaop.OpCopy
return true
case ssaop.OpCvtMask16x16to16:
- return rewriteValueAMD64_OpCvtMask16x16to16(v)
+ return rewriteValue_OpCvtMask16x16to16(v)
case ssaop.OpCvtMask16x32to32:
- return rewriteValueAMD64_OpCvtMask16x32to32(v)
+ return rewriteValue_OpCvtMask16x32to32(v)
case ssaop.OpCvtMask16x8to8:
- return rewriteValueAMD64_OpCvtMask16x8to8(v)
+ return rewriteValue_OpCvtMask16x8to8(v)
case ssaop.OpCvtMask32x16to16:
- return rewriteValueAMD64_OpCvtMask32x16to16(v)
+ return rewriteValue_OpCvtMask32x16to16(v)
case ssaop.OpCvtMask32x4to8:
v.Op = ssaop.OpAMD64VMOVMSKPS128
return true
@@ -4119,7 +4119,7 @@
v.Op = ssaop.OpAMD64VMOVMSKPD256
return true
case ssaop.OpCvtMask64x8to8:
- return rewriteValueAMD64_OpCvtMask64x8to8(v)
+ return rewriteValue_OpCvtMask64x8to8(v)
case ssaop.OpCvtMask8x16to16:
v.Op = ssaop.OpAMD64VPMOVMSKB128
return true
@@ -4127,32 +4127,32 @@
v.Op = ssaop.OpAMD64VPMOVMSKB256
return true
case ssaop.OpCvtMask8x64to64:
- return rewriteValueAMD64_OpCvtMask8x64to64(v)
+ return rewriteValue_OpCvtMask8x64to64(v)
case ssaop.OpDiv128u:
v.Op = ssaop.OpAMD64DIVQU2
return true
case ssaop.OpDiv16:
- return rewriteValueAMD64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueAMD64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueAMD64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpAMD64DIVSS
return true
case ssaop.OpDiv32u:
- return rewriteValueAMD64_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValueAMD64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpAMD64DIVSD
return true
case ssaop.OpDiv64u:
- return rewriteValueAMD64_OpDiv64u(v)
+ return rewriteValue_OpDiv64u(v)
case ssaop.OpDiv8:
- return rewriteValueAMD64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueAMD64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpDivFloat32x16:
v.Op = ssaop.OpAMD64VDIVPS512
return true
@@ -4190,43 +4190,43 @@
v.Op = ssaop.OpAMD64VPMADDUBSW512
return true
case ssaop.OpEq16:
- return rewriteValueAMD64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueAMD64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueAMD64_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValueAMD64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValueAMD64_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueAMD64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueAMD64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueAMD64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpEqualFloat32x16:
- return rewriteValueAMD64_OpEqualFloat32x16(v)
+ return rewriteValue_OpEqualFloat32x16(v)
case ssaop.OpEqualFloat32x4:
- return rewriteValueAMD64_OpEqualFloat32x4(v)
+ return rewriteValue_OpEqualFloat32x4(v)
case ssaop.OpEqualFloat32x8:
- return rewriteValueAMD64_OpEqualFloat32x8(v)
+ return rewriteValue_OpEqualFloat32x8(v)
case ssaop.OpEqualFloat64x2:
- return rewriteValueAMD64_OpEqualFloat64x2(v)
+ return rewriteValue_OpEqualFloat64x2(v)
case ssaop.OpEqualFloat64x4:
- return rewriteValueAMD64_OpEqualFloat64x4(v)
+ return rewriteValue_OpEqualFloat64x4(v)
case ssaop.OpEqualFloat64x8:
- return rewriteValueAMD64_OpEqualFloat64x8(v)
+ return rewriteValue_OpEqualFloat64x8(v)
case ssaop.OpEqualInt16x16:
v.Op = ssaop.OpAMD64VPCMPEQW256
return true
case ssaop.OpEqualInt16x32:
- return rewriteValueAMD64_OpEqualInt16x32(v)
+ return rewriteValue_OpEqualInt16x32(v)
case ssaop.OpEqualInt16x8:
v.Op = ssaop.OpAMD64VPCMPEQW128
return true
case ssaop.OpEqualInt32x16:
- return rewriteValueAMD64_OpEqualInt32x16(v)
+ return rewriteValue_OpEqualInt32x16(v)
case ssaop.OpEqualInt32x4:
v.Op = ssaop.OpAMD64VPCMPEQD128
return true
@@ -4240,7 +4240,7 @@
v.Op = ssaop.OpAMD64VPCMPEQQ256
return true
case ssaop.OpEqualInt64x8:
- return rewriteValueAMD64_OpEqualInt64x8(v)
+ return rewriteValue_OpEqualInt64x8(v)
case ssaop.OpEqualInt8x16:
v.Op = ssaop.OpAMD64VPCMPEQB128
return true
@@ -4248,17 +4248,17 @@
v.Op = ssaop.OpAMD64VPCMPEQB256
return true
case ssaop.OpEqualInt8x64:
- return rewriteValueAMD64_OpEqualInt8x64(v)
+ return rewriteValue_OpEqualInt8x64(v)
case ssaop.OpEqualUint16x16:
v.Op = ssaop.OpAMD64VPCMPEQW256
return true
case ssaop.OpEqualUint16x32:
- return rewriteValueAMD64_OpEqualUint16x32(v)
+ return rewriteValue_OpEqualUint16x32(v)
case ssaop.OpEqualUint16x8:
v.Op = ssaop.OpAMD64VPCMPEQW128
return true
case ssaop.OpEqualUint32x16:
- return rewriteValueAMD64_OpEqualUint32x16(v)
+ return rewriteValue_OpEqualUint32x16(v)
case ssaop.OpEqualUint32x4:
v.Op = ssaop.OpAMD64VPCMPEQD128
return true
@@ -4272,7 +4272,7 @@
v.Op = ssaop.OpAMD64VPCMPEQQ256
return true
case ssaop.OpEqualUint64x8:
- return rewriteValueAMD64_OpEqualUint64x8(v)
+ return rewriteValue_OpEqualUint64x8(v)
case ssaop.OpEqualUint8x16:
v.Op = ssaop.OpAMD64VPCMPEQB128
return true
@@ -4280,67 +4280,67 @@
v.Op = ssaop.OpAMD64VPCMPEQB256
return true
case ssaop.OpEqualUint8x64:
- return rewriteValueAMD64_OpEqualUint8x64(v)
+ return rewriteValue_OpEqualUint8x64(v)
case ssaop.OpExpandFloat32x16:
- return rewriteValueAMD64_OpExpandFloat32x16(v)
+ return rewriteValue_OpExpandFloat32x16(v)
case ssaop.OpExpandFloat32x4:
- return rewriteValueAMD64_OpExpandFloat32x4(v)
+ return rewriteValue_OpExpandFloat32x4(v)
case ssaop.OpExpandFloat32x8:
- return rewriteValueAMD64_OpExpandFloat32x8(v)
+ return rewriteValue_OpExpandFloat32x8(v)
case ssaop.OpExpandFloat64x2:
- return rewriteValueAMD64_OpExpandFloat64x2(v)
+ return rewriteValue_OpExpandFloat64x2(v)
case ssaop.OpExpandFloat64x4:
- return rewriteValueAMD64_OpExpandFloat64x4(v)
+ return rewriteValue_OpExpandFloat64x4(v)
case ssaop.OpExpandFloat64x8:
- return rewriteValueAMD64_OpExpandFloat64x8(v)
+ return rewriteValue_OpExpandFloat64x8(v)
case ssaop.OpExpandInt16x16:
- return rewriteValueAMD64_OpExpandInt16x16(v)
+ return rewriteValue_OpExpandInt16x16(v)
case ssaop.OpExpandInt16x32:
- return rewriteValueAMD64_OpExpandInt16x32(v)
+ return rewriteValue_OpExpandInt16x32(v)
case ssaop.OpExpandInt16x8:
- return rewriteValueAMD64_OpExpandInt16x8(v)
+ return rewriteValue_OpExpandInt16x8(v)
case ssaop.OpExpandInt32x16:
- return rewriteValueAMD64_OpExpandInt32x16(v)
+ return rewriteValue_OpExpandInt32x16(v)
case ssaop.OpExpandInt32x4:
- return rewriteValueAMD64_OpExpandInt32x4(v)
+ return rewriteValue_OpExpandInt32x4(v)
case ssaop.OpExpandInt32x8:
- return rewriteValueAMD64_OpExpandInt32x8(v)
+ return rewriteValue_OpExpandInt32x8(v)
case ssaop.OpExpandInt64x2:
- return rewriteValueAMD64_OpExpandInt64x2(v)
+ return rewriteValue_OpExpandInt64x2(v)
case ssaop.OpExpandInt64x4:
- return rewriteValueAMD64_OpExpandInt64x4(v)
+ return rewriteValue_OpExpandInt64x4(v)
case ssaop.OpExpandInt64x8:
- return rewriteValueAMD64_OpExpandInt64x8(v)
+ return rewriteValue_OpExpandInt64x8(v)
case ssaop.OpExpandInt8x16:
- return rewriteValueAMD64_OpExpandInt8x16(v)
+ return rewriteValue_OpExpandInt8x16(v)
case ssaop.OpExpandInt8x32:
- return rewriteValueAMD64_OpExpandInt8x32(v)
+ return rewriteValue_OpExpandInt8x32(v)
case ssaop.OpExpandInt8x64:
- return rewriteValueAMD64_OpExpandInt8x64(v)
+ return rewriteValue_OpExpandInt8x64(v)
case ssaop.OpExpandUint16x16:
- return rewriteValueAMD64_OpExpandUint16x16(v)
+ return rewriteValue_OpExpandUint16x16(v)
case ssaop.OpExpandUint16x32:
- return rewriteValueAMD64_OpExpandUint16x32(v)
+ return rewriteValue_OpExpandUint16x32(v)
case ssaop.OpExpandUint16x8:
- return rewriteValueAMD64_OpExpandUint16x8(v)
+ return rewriteValue_OpExpandUint16x8(v)
case ssaop.OpExpandUint32x16:
- return rewriteValueAMD64_OpExpandUint32x16(v)
+ return rewriteValue_OpExpandUint32x16(v)
case ssaop.OpExpandUint32x4:
- return rewriteValueAMD64_OpExpandUint32x4(v)
+ return rewriteValue_OpExpandUint32x4(v)
case ssaop.OpExpandUint32x8:
- return rewriteValueAMD64_OpExpandUint32x8(v)
+ return rewriteValue_OpExpandUint32x8(v)
case ssaop.OpExpandUint64x2:
- return rewriteValueAMD64_OpExpandUint64x2(v)
+ return rewriteValue_OpExpandUint64x2(v)
case ssaop.OpExpandUint64x4:
- return rewriteValueAMD64_OpExpandUint64x4(v)
+ return rewriteValue_OpExpandUint64x4(v)
case ssaop.OpExpandUint64x8:
- return rewriteValueAMD64_OpExpandUint64x8(v)
+ return rewriteValue_OpExpandUint64x8(v)
case ssaop.OpExpandUint8x16:
- return rewriteValueAMD64_OpExpandUint8x16(v)
+ return rewriteValue_OpExpandUint8x16(v)
case ssaop.OpExpandUint8x32:
- return rewriteValueAMD64_OpExpandUint8x32(v)
+ return rewriteValue_OpExpandUint8x32(v)
case ssaop.OpExpandUint8x64:
- return rewriteValueAMD64_OpExpandUint8x64(v)
+ return rewriteValue_OpExpandUint8x64(v)
case ssaop.OpExtendLo2ToInt64Int16x8:
v.Op = ssaop.OpAMD64VPMOVSXWQ128
return true
@@ -4450,41 +4450,41 @@
v.Op = ssaop.OpAMD64VPMOVZXDQ512
return true
case ssaop.OpFMA:
- return rewriteValueAMD64_OpFMA(v)
+ return rewriteValue_OpFMA(v)
case ssaop.OpFloor:
- return rewriteValueAMD64_OpFloor(v)
+ return rewriteValue_OpFloor(v)
case ssaop.OpFloorFloat32x4:
- return rewriteValueAMD64_OpFloorFloat32x4(v)
+ return rewriteValue_OpFloorFloat32x4(v)
case ssaop.OpFloorFloat32x8:
- return rewriteValueAMD64_OpFloorFloat32x8(v)
+ return rewriteValue_OpFloorFloat32x8(v)
case ssaop.OpFloorFloat64x2:
- return rewriteValueAMD64_OpFloorFloat64x2(v)
+ return rewriteValue_OpFloorFloat64x2(v)
case ssaop.OpFloorFloat64x4:
- return rewriteValueAMD64_OpFloorFloat64x4(v)
+ return rewriteValue_OpFloorFloat64x4(v)
case ssaop.OpFloorScaledFloat32x16:
- return rewriteValueAMD64_OpFloorScaledFloat32x16(v)
+ return rewriteValue_OpFloorScaledFloat32x16(v)
case ssaop.OpFloorScaledFloat32x4:
- return rewriteValueAMD64_OpFloorScaledFloat32x4(v)
+ return rewriteValue_OpFloorScaledFloat32x4(v)
case ssaop.OpFloorScaledFloat32x8:
- return rewriteValueAMD64_OpFloorScaledFloat32x8(v)
+ return rewriteValue_OpFloorScaledFloat32x8(v)
case ssaop.OpFloorScaledFloat64x2:
- return rewriteValueAMD64_OpFloorScaledFloat64x2(v)
+ return rewriteValue_OpFloorScaledFloat64x2(v)
case ssaop.OpFloorScaledFloat64x4:
- return rewriteValueAMD64_OpFloorScaledFloat64x4(v)
+ return rewriteValue_OpFloorScaledFloat64x4(v)
case ssaop.OpFloorScaledFloat64x8:
- return rewriteValueAMD64_OpFloorScaledFloat64x8(v)
+ return rewriteValue_OpFloorScaledFloat64x8(v)
case ssaop.OpFloorScaledResidueFloat32x16:
- return rewriteValueAMD64_OpFloorScaledResidueFloat32x16(v)
+ return rewriteValue_OpFloorScaledResidueFloat32x16(v)
case ssaop.OpFloorScaledResidueFloat32x4:
- return rewriteValueAMD64_OpFloorScaledResidueFloat32x4(v)
+ return rewriteValue_OpFloorScaledResidueFloat32x4(v)
case ssaop.OpFloorScaledResidueFloat32x8:
- return rewriteValueAMD64_OpFloorScaledResidueFloat32x8(v)
+ return rewriteValue_OpFloorScaledResidueFloat32x8(v)
case ssaop.OpFloorScaledResidueFloat64x2:
- return rewriteValueAMD64_OpFloorScaledResidueFloat64x2(v)
+ return rewriteValue_OpFloorScaledResidueFloat64x2(v)
case ssaop.OpFloorScaledResidueFloat64x4:
- return rewriteValueAMD64_OpFloorScaledResidueFloat64x4(v)
+ return rewriteValue_OpFloorScaledResidueFloat64x4(v)
case ssaop.OpFloorScaledResidueFloat64x8:
- return rewriteValueAMD64_OpFloorScaledResidueFloat64x8(v)
+ return rewriteValue_OpFloorScaledResidueFloat64x8(v)
case ssaop.OpGaloisFieldAffineTransformInverseUint8x16:
v.Op = ssaop.OpAMD64VGF2P8AFFINEINVQB128
return true
@@ -4552,137 +4552,137 @@
v.Op = ssaop.OpAMD64VPEXTRB128
return true
case ssaop.OpGetG:
- return rewriteValueAMD64_OpGetG(v)
+ return rewriteValue_OpGetG(v)
case ssaop.OpGetHiFloat32x16:
- return rewriteValueAMD64_OpGetHiFloat32x16(v)
+ return rewriteValue_OpGetHiFloat32x16(v)
case ssaop.OpGetHiFloat32x8:
- return rewriteValueAMD64_OpGetHiFloat32x8(v)
+ return rewriteValue_OpGetHiFloat32x8(v)
case ssaop.OpGetHiFloat64x4:
- return rewriteValueAMD64_OpGetHiFloat64x4(v)
+ return rewriteValue_OpGetHiFloat64x4(v)
case ssaop.OpGetHiFloat64x8:
- return rewriteValueAMD64_OpGetHiFloat64x8(v)
+ return rewriteValue_OpGetHiFloat64x8(v)
case ssaop.OpGetHiInt16x16:
- return rewriteValueAMD64_OpGetHiInt16x16(v)
+ return rewriteValue_OpGetHiInt16x16(v)
case ssaop.OpGetHiInt16x32:
- return rewriteValueAMD64_OpGetHiInt16x32(v)
+ return rewriteValue_OpGetHiInt16x32(v)
case ssaop.OpGetHiInt32x16:
- return rewriteValueAMD64_OpGetHiInt32x16(v)
+ return rewriteValue_OpGetHiInt32x16(v)
case ssaop.OpGetHiInt32x8:
- return rewriteValueAMD64_OpGetHiInt32x8(v)
+ return rewriteValue_OpGetHiInt32x8(v)
case ssaop.OpGetHiInt64x4:
- return rewriteValueAMD64_OpGetHiInt64x4(v)
+ return rewriteValue_OpGetHiInt64x4(v)
case ssaop.OpGetHiInt64x8:
- return rewriteValueAMD64_OpGetHiInt64x8(v)
+ return rewriteValue_OpGetHiInt64x8(v)
case ssaop.OpGetHiInt8x32:
- return rewriteValueAMD64_OpGetHiInt8x32(v)
+ return rewriteValue_OpGetHiInt8x32(v)
case ssaop.OpGetHiInt8x64:
- return rewriteValueAMD64_OpGetHiInt8x64(v)
+ return rewriteValue_OpGetHiInt8x64(v)
case ssaop.OpGetHiUint16x16:
- return rewriteValueAMD64_OpGetHiUint16x16(v)
+ return rewriteValue_OpGetHiUint16x16(v)
case ssaop.OpGetHiUint16x32:
- return rewriteValueAMD64_OpGetHiUint16x32(v)
+ return rewriteValue_OpGetHiUint16x32(v)
case ssaop.OpGetHiUint32x16:
- return rewriteValueAMD64_OpGetHiUint32x16(v)
+ return rewriteValue_OpGetHiUint32x16(v)
case ssaop.OpGetHiUint32x8:
- return rewriteValueAMD64_OpGetHiUint32x8(v)
+ return rewriteValue_OpGetHiUint32x8(v)
case ssaop.OpGetHiUint64x4:
- return rewriteValueAMD64_OpGetHiUint64x4(v)
+ return rewriteValue_OpGetHiUint64x4(v)
case ssaop.OpGetHiUint64x8:
- return rewriteValueAMD64_OpGetHiUint64x8(v)
+ return rewriteValue_OpGetHiUint64x8(v)
case ssaop.OpGetHiUint8x32:
- return rewriteValueAMD64_OpGetHiUint8x32(v)
+ return rewriteValue_OpGetHiUint8x32(v)
case ssaop.OpGetHiUint8x64:
- return rewriteValueAMD64_OpGetHiUint8x64(v)
+ return rewriteValue_OpGetHiUint8x64(v)
case ssaop.OpGetLoFloat32x16:
- return rewriteValueAMD64_OpGetLoFloat32x16(v)
+ return rewriteValue_OpGetLoFloat32x16(v)
case ssaop.OpGetLoFloat32x8:
- return rewriteValueAMD64_OpGetLoFloat32x8(v)
+ return rewriteValue_OpGetLoFloat32x8(v)
case ssaop.OpGetLoFloat64x4:
- return rewriteValueAMD64_OpGetLoFloat64x4(v)
+ return rewriteValue_OpGetLoFloat64x4(v)
case ssaop.OpGetLoFloat64x8:
- return rewriteValueAMD64_OpGetLoFloat64x8(v)
+ return rewriteValue_OpGetLoFloat64x8(v)
case ssaop.OpGetLoInt16x16:
- return rewriteValueAMD64_OpGetLoInt16x16(v)
+ return rewriteValue_OpGetLoInt16x16(v)
case ssaop.OpGetLoInt16x32:
- return rewriteValueAMD64_OpGetLoInt16x32(v)
+ return rewriteValue_OpGetLoInt16x32(v)
case ssaop.OpGetLoInt32x16:
- return rewriteValueAMD64_OpGetLoInt32x16(v)
+ return rewriteValue_OpGetLoInt32x16(v)
case ssaop.OpGetLoInt32x8:
- return rewriteValueAMD64_OpGetLoInt32x8(v)
+ return rewriteValue_OpGetLoInt32x8(v)
case ssaop.OpGetLoInt64x4:
- return rewriteValueAMD64_OpGetLoInt64x4(v)
+ return rewriteValue_OpGetLoInt64x4(v)
case ssaop.OpGetLoInt64x8:
- return rewriteValueAMD64_OpGetLoInt64x8(v)
+ return rewriteValue_OpGetLoInt64x8(v)
case ssaop.OpGetLoInt8x32:
- return rewriteValueAMD64_OpGetLoInt8x32(v)
+ return rewriteValue_OpGetLoInt8x32(v)
case ssaop.OpGetLoInt8x64:
- return rewriteValueAMD64_OpGetLoInt8x64(v)
+ return rewriteValue_OpGetLoInt8x64(v)
case ssaop.OpGetLoUint16x16:
- return rewriteValueAMD64_OpGetLoUint16x16(v)
+ return rewriteValue_OpGetLoUint16x16(v)
case ssaop.OpGetLoUint16x32:
- return rewriteValueAMD64_OpGetLoUint16x32(v)
+ return rewriteValue_OpGetLoUint16x32(v)
case ssaop.OpGetLoUint32x16:
- return rewriteValueAMD64_OpGetLoUint32x16(v)
+ return rewriteValue_OpGetLoUint32x16(v)
case ssaop.OpGetLoUint32x8:
- return rewriteValueAMD64_OpGetLoUint32x8(v)
+ return rewriteValue_OpGetLoUint32x8(v)
case ssaop.OpGetLoUint64x4:
- return rewriteValueAMD64_OpGetLoUint64x4(v)
+ return rewriteValue_OpGetLoUint64x4(v)
case ssaop.OpGetLoUint64x8:
- return rewriteValueAMD64_OpGetLoUint64x8(v)
+ return rewriteValue_OpGetLoUint64x8(v)
case ssaop.OpGetLoUint8x32:
- return rewriteValueAMD64_OpGetLoUint8x32(v)
+ return rewriteValue_OpGetLoUint8x32(v)
case ssaop.OpGetLoUint8x64:
- return rewriteValueAMD64_OpGetLoUint8x64(v)
+ return rewriteValue_OpGetLoUint8x64(v)
case ssaop.OpGreaterEqualFloat32x16:
- return rewriteValueAMD64_OpGreaterEqualFloat32x16(v)
+ return rewriteValue_OpGreaterEqualFloat32x16(v)
case ssaop.OpGreaterEqualFloat32x4:
- return rewriteValueAMD64_OpGreaterEqualFloat32x4(v)
+ return rewriteValue_OpGreaterEqualFloat32x4(v)
case ssaop.OpGreaterEqualFloat32x8:
- return rewriteValueAMD64_OpGreaterEqualFloat32x8(v)
+ return rewriteValue_OpGreaterEqualFloat32x8(v)
case ssaop.OpGreaterEqualFloat64x2:
- return rewriteValueAMD64_OpGreaterEqualFloat64x2(v)
+ return rewriteValue_OpGreaterEqualFloat64x2(v)
case ssaop.OpGreaterEqualFloat64x4:
- return rewriteValueAMD64_OpGreaterEqualFloat64x4(v)
+ return rewriteValue_OpGreaterEqualFloat64x4(v)
case ssaop.OpGreaterEqualFloat64x8:
- return rewriteValueAMD64_OpGreaterEqualFloat64x8(v)
+ return rewriteValue_OpGreaterEqualFloat64x8(v)
case ssaop.OpGreaterEqualInt16x32:
- return rewriteValueAMD64_OpGreaterEqualInt16x32(v)
+ return rewriteValue_OpGreaterEqualInt16x32(v)
case ssaop.OpGreaterEqualInt32x16:
- return rewriteValueAMD64_OpGreaterEqualInt32x16(v)
+ return rewriteValue_OpGreaterEqualInt32x16(v)
case ssaop.OpGreaterEqualInt64x8:
- return rewriteValueAMD64_OpGreaterEqualInt64x8(v)
+ return rewriteValue_OpGreaterEqualInt64x8(v)
case ssaop.OpGreaterEqualInt8x64:
- return rewriteValueAMD64_OpGreaterEqualInt8x64(v)
+ return rewriteValue_OpGreaterEqualInt8x64(v)
case ssaop.OpGreaterEqualUint16x32:
- return rewriteValueAMD64_OpGreaterEqualUint16x32(v)
+ return rewriteValue_OpGreaterEqualUint16x32(v)
case ssaop.OpGreaterEqualUint32x16:
- return rewriteValueAMD64_OpGreaterEqualUint32x16(v)
+ return rewriteValue_OpGreaterEqualUint32x16(v)
case ssaop.OpGreaterEqualUint64x8:
- return rewriteValueAMD64_OpGreaterEqualUint64x8(v)
+ return rewriteValue_OpGreaterEqualUint64x8(v)
case ssaop.OpGreaterEqualUint8x64:
- return rewriteValueAMD64_OpGreaterEqualUint8x64(v)
+ return rewriteValue_OpGreaterEqualUint8x64(v)
case ssaop.OpGreaterFloat32x16:
- return rewriteValueAMD64_OpGreaterFloat32x16(v)
+ return rewriteValue_OpGreaterFloat32x16(v)
case ssaop.OpGreaterFloat32x4:
- return rewriteValueAMD64_OpGreaterFloat32x4(v)
+ return rewriteValue_OpGreaterFloat32x4(v)
case ssaop.OpGreaterFloat32x8:
- return rewriteValueAMD64_OpGreaterFloat32x8(v)
+ return rewriteValue_OpGreaterFloat32x8(v)
case ssaop.OpGreaterFloat64x2:
- return rewriteValueAMD64_OpGreaterFloat64x2(v)
+ return rewriteValue_OpGreaterFloat64x2(v)
case ssaop.OpGreaterFloat64x4:
- return rewriteValueAMD64_OpGreaterFloat64x4(v)
+ return rewriteValue_OpGreaterFloat64x4(v)
case ssaop.OpGreaterFloat64x8:
- return rewriteValueAMD64_OpGreaterFloat64x8(v)
+ return rewriteValue_OpGreaterFloat64x8(v)
case ssaop.OpGreaterInt16x16:
v.Op = ssaop.OpAMD64VPCMPGTW256
return true
case ssaop.OpGreaterInt16x32:
- return rewriteValueAMD64_OpGreaterInt16x32(v)
+ return rewriteValue_OpGreaterInt16x32(v)
case ssaop.OpGreaterInt16x8:
v.Op = ssaop.OpAMD64VPCMPGTW128
return true
case ssaop.OpGreaterInt32x16:
- return rewriteValueAMD64_OpGreaterInt32x16(v)
+ return rewriteValue_OpGreaterInt32x16(v)
case ssaop.OpGreaterInt32x4:
v.Op = ssaop.OpAMD64VPCMPGTD128
return true
@@ -4696,7 +4696,7 @@
v.Op = ssaop.OpAMD64VPCMPGTQ256
return true
case ssaop.OpGreaterInt64x8:
- return rewriteValueAMD64_OpGreaterInt64x8(v)
+ return rewriteValue_OpGreaterInt64x8(v)
case ssaop.OpGreaterInt8x16:
v.Op = ssaop.OpAMD64VPCMPGTB128
return true
@@ -4704,17 +4704,17 @@
v.Op = ssaop.OpAMD64VPCMPGTB256
return true
case ssaop.OpGreaterInt8x64:
- return rewriteValueAMD64_OpGreaterInt8x64(v)
+ return rewriteValue_OpGreaterInt8x64(v)
case ssaop.OpGreaterUint16x32:
- return rewriteValueAMD64_OpGreaterUint16x32(v)
+ return rewriteValue_OpGreaterUint16x32(v)
case ssaop.OpGreaterUint32x16:
- return rewriteValueAMD64_OpGreaterUint32x16(v)
+ return rewriteValue_OpGreaterUint32x16(v)
case ssaop.OpGreaterUint64x8:
- return rewriteValueAMD64_OpGreaterUint64x8(v)
+ return rewriteValue_OpGreaterUint64x8(v)
case ssaop.OpGreaterUint8x64:
- return rewriteValueAMD64_OpGreaterUint8x64(v)
+ return rewriteValue_OpGreaterUint8x64(v)
case ssaop.OpHasCPUFeature:
- return rewriteValueAMD64_OpHasCPUFeature(v)
+ return rewriteValue_OpHasCPUFeature(v)
case ssaop.OpHmul32:
v.Op = ssaop.OpAMD64HMULL
return true
@@ -4839,25 +4839,25 @@
v.Op = ssaop.OpAMD64VPUNPCKLQDQ128
return true
case ssaop.OpIsInBounds:
- return rewriteValueAMD64_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNaNFloat32x16:
- return rewriteValueAMD64_OpIsNaNFloat32x16(v)
+ return rewriteValue_OpIsNaNFloat32x16(v)
case ssaop.OpIsNaNFloat32x4:
- return rewriteValueAMD64_OpIsNaNFloat32x4(v)
+ return rewriteValue_OpIsNaNFloat32x4(v)
case ssaop.OpIsNaNFloat32x8:
- return rewriteValueAMD64_OpIsNaNFloat32x8(v)
+ return rewriteValue_OpIsNaNFloat32x8(v)
case ssaop.OpIsNaNFloat64x2:
- return rewriteValueAMD64_OpIsNaNFloat64x2(v)
+ return rewriteValue_OpIsNaNFloat64x2(v)
case ssaop.OpIsNaNFloat64x4:
- return rewriteValueAMD64_OpIsNaNFloat64x4(v)
+ return rewriteValue_OpIsNaNFloat64x4(v)
case ssaop.OpIsNaNFloat64x8:
- return rewriteValueAMD64_OpIsNaNFloat64x8(v)
+ return rewriteValue_OpIsNaNFloat64x8(v)
case ssaop.OpIsNonNil:
- return rewriteValueAMD64_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueAMD64_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpIsZeroVec:
- return rewriteValueAMD64_OpIsZeroVec(v)
+ return rewriteValue_OpIsZeroVec(v)
case ssaop.OpLeadingZerosInt32x16:
v.Op = ssaop.OpAMD64VPLZCNTD512
return true
@@ -4895,152 +4895,152 @@
v.Op = ssaop.OpAMD64VPLZCNTQ512
return true
case ssaop.OpLeq16:
- return rewriteValueAMD64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueAMD64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueAMD64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueAMD64_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueAMD64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueAMD64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValueAMD64_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValueAMD64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueAMD64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueAMD64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueAMD64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueAMD64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueAMD64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueAMD64_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueAMD64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValueAMD64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValueAMD64_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValueAMD64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValueAMD64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueAMD64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLessEqualFloat32x16:
- return rewriteValueAMD64_OpLessEqualFloat32x16(v)
+ return rewriteValue_OpLessEqualFloat32x16(v)
case ssaop.OpLessEqualFloat32x4:
- return rewriteValueAMD64_OpLessEqualFloat32x4(v)
+ return rewriteValue_OpLessEqualFloat32x4(v)
case ssaop.OpLessEqualFloat32x8:
- return rewriteValueAMD64_OpLessEqualFloat32x8(v)
+ return rewriteValue_OpLessEqualFloat32x8(v)
case ssaop.OpLessEqualFloat64x2:
- return rewriteValueAMD64_OpLessEqualFloat64x2(v)
+ return rewriteValue_OpLessEqualFloat64x2(v)
case ssaop.OpLessEqualFloat64x4:
- return rewriteValueAMD64_OpLessEqualFloat64x4(v)
+ return rewriteValue_OpLessEqualFloat64x4(v)
case ssaop.OpLessEqualFloat64x8:
- return rewriteValueAMD64_OpLessEqualFloat64x8(v)
+ return rewriteValue_OpLessEqualFloat64x8(v)
case ssaop.OpLessEqualInt16x32:
- return rewriteValueAMD64_OpLessEqualInt16x32(v)
+ return rewriteValue_OpLessEqualInt16x32(v)
case ssaop.OpLessEqualInt32x16:
- return rewriteValueAMD64_OpLessEqualInt32x16(v)
+ return rewriteValue_OpLessEqualInt32x16(v)
case ssaop.OpLessEqualInt64x8:
- return rewriteValueAMD64_OpLessEqualInt64x8(v)
+ return rewriteValue_OpLessEqualInt64x8(v)
case ssaop.OpLessEqualInt8x64:
- return rewriteValueAMD64_OpLessEqualInt8x64(v)
+ return rewriteValue_OpLessEqualInt8x64(v)
case ssaop.OpLessEqualUint16x32:
- return rewriteValueAMD64_OpLessEqualUint16x32(v)
+ return rewriteValue_OpLessEqualUint16x32(v)
case ssaop.OpLessEqualUint32x16:
- return rewriteValueAMD64_OpLessEqualUint32x16(v)
+ return rewriteValue_OpLessEqualUint32x16(v)
case ssaop.OpLessEqualUint64x8:
- return rewriteValueAMD64_OpLessEqualUint64x8(v)
+ return rewriteValue_OpLessEqualUint64x8(v)
case ssaop.OpLessEqualUint8x64:
- return rewriteValueAMD64_OpLessEqualUint8x64(v)
+ return rewriteValue_OpLessEqualUint8x64(v)
case ssaop.OpLessFloat32x16:
- return rewriteValueAMD64_OpLessFloat32x16(v)
+ return rewriteValue_OpLessFloat32x16(v)
case ssaop.OpLessFloat32x4:
- return rewriteValueAMD64_OpLessFloat32x4(v)
+ return rewriteValue_OpLessFloat32x4(v)
case ssaop.OpLessFloat32x8:
- return rewriteValueAMD64_OpLessFloat32x8(v)
+ return rewriteValue_OpLessFloat32x8(v)
case ssaop.OpLessFloat64x2:
- return rewriteValueAMD64_OpLessFloat64x2(v)
+ return rewriteValue_OpLessFloat64x2(v)
case ssaop.OpLessFloat64x4:
- return rewriteValueAMD64_OpLessFloat64x4(v)
+ return rewriteValue_OpLessFloat64x4(v)
case ssaop.OpLessFloat64x8:
- return rewriteValueAMD64_OpLessFloat64x8(v)
+ return rewriteValue_OpLessFloat64x8(v)
case ssaop.OpLessInt16x32:
- return rewriteValueAMD64_OpLessInt16x32(v)
+ return rewriteValue_OpLessInt16x32(v)
case ssaop.OpLessInt32x16:
- return rewriteValueAMD64_OpLessInt32x16(v)
+ return rewriteValue_OpLessInt32x16(v)
case ssaop.OpLessInt64x8:
- return rewriteValueAMD64_OpLessInt64x8(v)
+ return rewriteValue_OpLessInt64x8(v)
case ssaop.OpLessInt8x64:
- return rewriteValueAMD64_OpLessInt8x64(v)
+ return rewriteValue_OpLessInt8x64(v)
case ssaop.OpLessUint16x32:
- return rewriteValueAMD64_OpLessUint16x32(v)
+ return rewriteValue_OpLessUint16x32(v)
case ssaop.OpLessUint32x16:
- return rewriteValueAMD64_OpLessUint32x16(v)
+ return rewriteValue_OpLessUint32x16(v)
case ssaop.OpLessUint64x8:
- return rewriteValueAMD64_OpLessUint64x8(v)
+ return rewriteValue_OpLessUint64x8(v)
case ssaop.OpLessUint8x64:
- return rewriteValueAMD64_OpLessUint8x64(v)
+ return rewriteValue_OpLessUint8x64(v)
case ssaop.OpLoad:
- return rewriteValueAMD64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLoadMasked16:
- return rewriteValueAMD64_OpLoadMasked16(v)
+ return rewriteValue_OpLoadMasked16(v)
case ssaop.OpLoadMasked32:
- return rewriteValueAMD64_OpLoadMasked32(v)
+ return rewriteValue_OpLoadMasked32(v)
case ssaop.OpLoadMasked64:
- return rewriteValueAMD64_OpLoadMasked64(v)
+ return rewriteValue_OpLoadMasked64(v)
case ssaop.OpLoadMasked8:
- return rewriteValueAMD64_OpLoadMasked8(v)
+ return rewriteValue_OpLoadMasked8(v)
case ssaop.OpLocalAddr:
- return rewriteValueAMD64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueAMD64_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueAMD64_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueAMD64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueAMD64_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueAMD64_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueAMD64_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueAMD64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueAMD64_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueAMD64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueAMD64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueAMD64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueAMD64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueAMD64_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueAMD64_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueAMD64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueAMD64_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMax32F:
- return rewriteValueAMD64_OpMax32F(v)
+ return rewriteValue_OpMax32F(v)
case ssaop.OpMax32FSel:
v.Op = ssaop.OpAMD64MAXSS
return true
case ssaop.OpMax64F:
- return rewriteValueAMD64_OpMax64F(v)
+ return rewriteValue_OpMax64F(v)
case ssaop.OpMax64FSel:
v.Op = ssaop.OpAMD64MAXSD
return true
@@ -5135,12 +5135,12 @@
v.Op = ssaop.OpAMD64VPMAXUB512
return true
case ssaop.OpMin32F:
- return rewriteValueAMD64_OpMin32F(v)
+ return rewriteValue_OpMin32F(v)
case ssaop.OpMin32FSel:
v.Op = ssaop.OpAMD64MINSS
return true
case ssaop.OpMin64F:
- return rewriteValueAMD64_OpMin64F(v)
+ return rewriteValue_OpMin64F(v)
case ssaop.OpMin64FSel:
v.Op = ssaop.OpAMD64MINSD
return true
@@ -5235,23 +5235,23 @@
v.Op = ssaop.OpAMD64VPMINUB512
return true
case ssaop.OpMod16:
- return rewriteValueAMD64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueAMD64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueAMD64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueAMD64_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValueAMD64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
- return rewriteValueAMD64_OpMod64u(v)
+ return rewriteValue_OpMod64u(v)
case ssaop.OpMod8:
- return rewriteValueAMD64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueAMD64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueAMD64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpAMD64MULL
return true
@@ -5268,7 +5268,7 @@
v.Op = ssaop.OpAMD64MULSD
return true
case ssaop.OpMul64uhilo:
- return rewriteValueAMD64_OpMul64uhilo(v)
+ return rewriteValue_OpMul64uhilo(v)
case ssaop.OpMul8:
v.Op = ssaop.OpAMD64MULL
return true
@@ -5453,66 +5453,66 @@
v.Op = ssaop.OpAMD64NEGL
return true
case ssaop.OpNeg32F:
- return rewriteValueAMD64_OpNeg32F(v)
+ return rewriteValue_OpNeg32F(v)
case ssaop.OpNeg64:
v.Op = ssaop.OpAMD64NEGQ
return true
case ssaop.OpNeg64F:
- return rewriteValueAMD64_OpNeg64F(v)
+ return rewriteValue_OpNeg64F(v)
case ssaop.OpNeg8:
v.Op = ssaop.OpAMD64NEGL
return true
case ssaop.OpNeq16:
- return rewriteValueAMD64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueAMD64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueAMD64_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValueAMD64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValueAMD64_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueAMD64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
- return rewriteValueAMD64_OpNeqB(v)
+ return rewriteValue_OpNeqB(v)
case ssaop.OpNeqPtr:
- return rewriteValueAMD64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpAMD64LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueAMD64_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpNotEqualFloat32x16:
- return rewriteValueAMD64_OpNotEqualFloat32x16(v)
+ return rewriteValue_OpNotEqualFloat32x16(v)
case ssaop.OpNotEqualFloat32x4:
- return rewriteValueAMD64_OpNotEqualFloat32x4(v)
+ return rewriteValue_OpNotEqualFloat32x4(v)
case ssaop.OpNotEqualFloat32x8:
- return rewriteValueAMD64_OpNotEqualFloat32x8(v)
+ return rewriteValue_OpNotEqualFloat32x8(v)
case ssaop.OpNotEqualFloat64x2:
- return rewriteValueAMD64_OpNotEqualFloat64x2(v)
+ return rewriteValue_OpNotEqualFloat64x2(v)
case ssaop.OpNotEqualFloat64x4:
- return rewriteValueAMD64_OpNotEqualFloat64x4(v)
+ return rewriteValue_OpNotEqualFloat64x4(v)
case ssaop.OpNotEqualFloat64x8:
- return rewriteValueAMD64_OpNotEqualFloat64x8(v)
+ return rewriteValue_OpNotEqualFloat64x8(v)
case ssaop.OpNotEqualInt16x32:
- return rewriteValueAMD64_OpNotEqualInt16x32(v)
+ return rewriteValue_OpNotEqualInt16x32(v)
case ssaop.OpNotEqualInt32x16:
- return rewriteValueAMD64_OpNotEqualInt32x16(v)
+ return rewriteValue_OpNotEqualInt32x16(v)
case ssaop.OpNotEqualInt64x8:
- return rewriteValueAMD64_OpNotEqualInt64x8(v)
+ return rewriteValue_OpNotEqualInt64x8(v)
case ssaop.OpNotEqualInt8x64:
- return rewriteValueAMD64_OpNotEqualInt8x64(v)
+ return rewriteValue_OpNotEqualInt8x64(v)
case ssaop.OpNotEqualUint16x32:
- return rewriteValueAMD64_OpNotEqualUint16x32(v)
+ return rewriteValue_OpNotEqualUint16x32(v)
case ssaop.OpNotEqualUint32x16:
- return rewriteValueAMD64_OpNotEqualUint32x16(v)
+ return rewriteValue_OpNotEqualUint32x16(v)
case ssaop.OpNotEqualUint64x8:
- return rewriteValueAMD64_OpNotEqualUint64x8(v)
+ return rewriteValue_OpNotEqualUint64x8(v)
case ssaop.OpNotEqualUint8x64:
- return rewriteValueAMD64_OpNotEqualUint8x64(v)
+ return rewriteValue_OpNotEqualUint8x64(v)
case ssaop.OpOffPtr:
- return rewriteValueAMD64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOnesCountInt16x16:
v.Op = ssaop.OpAMD64VPOPCNTW256
return true
@@ -5766,7 +5766,7 @@
v.Op = ssaop.OpAMD64VPERMB512
return true
case ssaop.OpPopCount16:
- return rewriteValueAMD64_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
v.Op = ssaop.OpAMD64POPCNTL
return true
@@ -5774,7 +5774,7 @@
v.Op = ssaop.OpAMD64POPCNTQ
return true
case ssaop.OpPopCount8:
- return rewriteValueAMD64_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpPrefetchCache:
v.Op = ssaop.OpAMD64PrefetchT0
return true
@@ -5908,103 +5908,103 @@
v.Op = ssaop.OpAMD64LoweredRound64F
return true
case ssaop.OpRoundFloat32x4:
- return rewriteValueAMD64_OpRoundFloat32x4(v)
+ return rewriteValue_OpRoundFloat32x4(v)
case ssaop.OpRoundFloat32x8:
- return rewriteValueAMD64_OpRoundFloat32x8(v)
+ return rewriteValue_OpRoundFloat32x8(v)
case ssaop.OpRoundFloat64x2:
- return rewriteValueAMD64_OpRoundFloat64x2(v)
+ return rewriteValue_OpRoundFloat64x2(v)
case ssaop.OpRoundFloat64x4:
- return rewriteValueAMD64_OpRoundFloat64x4(v)
+ return rewriteValue_OpRoundFloat64x4(v)
case ssaop.OpRoundScaledFloat32x16:
- return rewriteValueAMD64_OpRoundScaledFloat32x16(v)
+ return rewriteValue_OpRoundScaledFloat32x16(v)
case ssaop.OpRoundScaledFloat32x4:
- return rewriteValueAMD64_OpRoundScaledFloat32x4(v)
+ return rewriteValue_OpRoundScaledFloat32x4(v)
case ssaop.OpRoundScaledFloat32x8:
- return rewriteValueAMD64_OpRoundScaledFloat32x8(v)
+ return rewriteValue_OpRoundScaledFloat32x8(v)
case ssaop.OpRoundScaledFloat64x2:
- return rewriteValueAMD64_OpRoundScaledFloat64x2(v)
+ return rewriteValue_OpRoundScaledFloat64x2(v)
case ssaop.OpRoundScaledFloat64x4:
- return rewriteValueAMD64_OpRoundScaledFloat64x4(v)
+ return rewriteValue_OpRoundScaledFloat64x4(v)
case ssaop.OpRoundScaledFloat64x8:
- return rewriteValueAMD64_OpRoundScaledFloat64x8(v)
+ return rewriteValue_OpRoundScaledFloat64x8(v)
case ssaop.OpRoundScaledResidueFloat32x16:
- return rewriteValueAMD64_OpRoundScaledResidueFloat32x16(v)
+ return rewriteValue_OpRoundScaledResidueFloat32x16(v)
case ssaop.OpRoundScaledResidueFloat32x4:
- return rewriteValueAMD64_OpRoundScaledResidueFloat32x4(v)
+ return rewriteValue_OpRoundScaledResidueFloat32x4(v)
case ssaop.OpRoundScaledResidueFloat32x8:
- return rewriteValueAMD64_OpRoundScaledResidueFloat32x8(v)
+ return rewriteValue_OpRoundScaledResidueFloat32x8(v)
case ssaop.OpRoundScaledResidueFloat64x2:
- return rewriteValueAMD64_OpRoundScaledResidueFloat64x2(v)
+ return rewriteValue_OpRoundScaledResidueFloat64x2(v)
case ssaop.OpRoundScaledResidueFloat64x4:
- return rewriteValueAMD64_OpRoundScaledResidueFloat64x4(v)
+ return rewriteValue_OpRoundScaledResidueFloat64x4(v)
case ssaop.OpRoundScaledResidueFloat64x8:
- return rewriteValueAMD64_OpRoundScaledResidueFloat64x8(v)
+ return rewriteValue_OpRoundScaledResidueFloat64x8(v)
case ssaop.OpRoundToEven:
- return rewriteValueAMD64_OpRoundToEven(v)
+ return rewriteValue_OpRoundToEven(v)
case ssaop.OpRsh16Ux16:
- return rewriteValueAMD64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueAMD64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueAMD64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueAMD64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueAMD64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueAMD64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueAMD64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueAMD64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueAMD64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueAMD64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueAMD64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueAMD64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueAMD64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueAMD64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueAMD64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueAMD64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueAMD64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueAMD64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueAMD64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueAMD64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueAMD64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueAMD64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueAMD64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueAMD64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueAMD64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueAMD64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueAMD64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueAMD64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueAMD64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueAMD64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueAMD64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueAMD64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSHA1FourRoundsUint32x4:
v.Op = ssaop.OpAMD64SHA1RNDS4128
return true
@@ -6171,11 +6171,11 @@
v.Op = ssaop.OpAMD64VSCALEFPD512
return true
case ssaop.OpSelect0:
- return rewriteValueAMD64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueAMD64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSelectN:
- return rewriteValueAMD64_OpSelectN(v)
+ return rewriteValue_OpSelectN(v)
case ssaop.OpSetElemFloat32x4:
v.Op = ssaop.OpAMD64VPINSRD128
return true
@@ -6207,85 +6207,85 @@
v.Op = ssaop.OpAMD64VPINSRB128
return true
case ssaop.OpSetHiFloat32x16:
- return rewriteValueAMD64_OpSetHiFloat32x16(v)
+ return rewriteValue_OpSetHiFloat32x16(v)
case ssaop.OpSetHiFloat32x8:
- return rewriteValueAMD64_OpSetHiFloat32x8(v)
+ return rewriteValue_OpSetHiFloat32x8(v)
case ssaop.OpSetHiFloat64x4:
- return rewriteValueAMD64_OpSetHiFloat64x4(v)
+ return rewriteValue_OpSetHiFloat64x4(v)
case ssaop.OpSetHiFloat64x8:
- return rewriteValueAMD64_OpSetHiFloat64x8(v)
+ return rewriteValue_OpSetHiFloat64x8(v)
case ssaop.OpSetHiInt16x16:
- return rewriteValueAMD64_OpSetHiInt16x16(v)
+ return rewriteValue_OpSetHiInt16x16(v)
case ssaop.OpSetHiInt16x32:
- return rewriteValueAMD64_OpSetHiInt16x32(v)
+ return rewriteValue_OpSetHiInt16x32(v)
case ssaop.OpSetHiInt32x16:
- return rewriteValueAMD64_OpSetHiInt32x16(v)
+ return rewriteValue_OpSetHiInt32x16(v)
case ssaop.OpSetHiInt32x8:
- return rewriteValueAMD64_OpSetHiInt32x8(v)
+ return rewriteValue_OpSetHiInt32x8(v)
case ssaop.OpSetHiInt64x4:
- return rewriteValueAMD64_OpSetHiInt64x4(v)
+ return rewriteValue_OpSetHiInt64x4(v)
case ssaop.OpSetHiInt64x8:
- return rewriteValueAMD64_OpSetHiInt64x8(v)
+ return rewriteValue_OpSetHiInt64x8(v)
case ssaop.OpSetHiInt8x32:
- return rewriteValueAMD64_OpSetHiInt8x32(v)
+ return rewriteValue_OpSetHiInt8x32(v)
case ssaop.OpSetHiInt8x64:
- return rewriteValueAMD64_OpSetHiInt8x64(v)
+ return rewriteValue_OpSetHiInt8x64(v)
case ssaop.OpSetHiUint16x16:
- return rewriteValueAMD64_OpSetHiUint16x16(v)
+ return rewriteValue_OpSetHiUint16x16(v)
case ssaop.OpSetHiUint16x32:
- return rewriteValueAMD64_OpSetHiUint16x32(v)
+ return rewriteValue_OpSetHiUint16x32(v)
case ssaop.OpSetHiUint32x16:
- return rewriteValueAMD64_OpSetHiUint32x16(v)
+ return rewriteValue_OpSetHiUint32x16(v)
case ssaop.OpSetHiUint32x8:
- return rewriteValueAMD64_OpSetHiUint32x8(v)
+ return rewriteValue_OpSetHiUint32x8(v)
case ssaop.OpSetHiUint64x4:
- return rewriteValueAMD64_OpSetHiUint64x4(v)
+ return rewriteValue_OpSetHiUint64x4(v)
case ssaop.OpSetHiUint64x8:
- return rewriteValueAMD64_OpSetHiUint64x8(v)
+ return rewriteValue_OpSetHiUint64x8(v)
case ssaop.OpSetHiUint8x32:
- return rewriteValueAMD64_OpSetHiUint8x32(v)
+ return rewriteValue_OpSetHiUint8x32(v)
case ssaop.OpSetHiUint8x64:
- return rewriteValueAMD64_OpSetHiUint8x64(v)
+ return rewriteValue_OpSetHiUint8x64(v)
case ssaop.OpSetLoFloat32x16:
- return rewriteValueAMD64_OpSetLoFloat32x16(v)
+ return rewriteValue_OpSetLoFloat32x16(v)
case ssaop.OpSetLoFloat32x8:
- return rewriteValueAMD64_OpSetLoFloat32x8(v)
+ return rewriteValue_OpSetLoFloat32x8(v)
case ssaop.OpSetLoFloat64x4:
- return rewriteValueAMD64_OpSetLoFloat64x4(v)
+ return rewriteValue_OpSetLoFloat64x4(v)
case ssaop.OpSetLoFloat64x8:
- return rewriteValueAMD64_OpSetLoFloat64x8(v)
+ return rewriteValue_OpSetLoFloat64x8(v)
case ssaop.OpSetLoInt16x16:
- return rewriteValueAMD64_OpSetLoInt16x16(v)
+ return rewriteValue_OpSetLoInt16x16(v)
case ssaop.OpSetLoInt16x32:
- return rewriteValueAMD64_OpSetLoInt16x32(v)
+ return rewriteValue_OpSetLoInt16x32(v)
case ssaop.OpSetLoInt32x16:
- return rewriteValueAMD64_OpSetLoInt32x16(v)
+ return rewriteValue_OpSetLoInt32x16(v)
case ssaop.OpSetLoInt32x8:
- return rewriteValueAMD64_OpSetLoInt32x8(v)
+ return rewriteValue_OpSetLoInt32x8(v)
case ssaop.OpSetLoInt64x4:
- return rewriteValueAMD64_OpSetLoInt64x4(v)
+ return rewriteValue_OpSetLoInt64x4(v)
case ssaop.OpSetLoInt64x8:
- return rewriteValueAMD64_OpSetLoInt64x8(v)
+ return rewriteValue_OpSetLoInt64x8(v)
case ssaop.OpSetLoInt8x32:
- return rewriteValueAMD64_OpSetLoInt8x32(v)
+ return rewriteValue_OpSetLoInt8x32(v)
case ssaop.OpSetLoInt8x64:
- return rewriteValueAMD64_OpSetLoInt8x64(v)
+ return rewriteValue_OpSetLoInt8x64(v)
case ssaop.OpSetLoUint16x16:
- return rewriteValueAMD64_OpSetLoUint16x16(v)
+ return rewriteValue_OpSetLoUint16x16(v)
case ssaop.OpSetLoUint16x32:
- return rewriteValueAMD64_OpSetLoUint16x32(v)
+ return rewriteValue_OpSetLoUint16x32(v)
case ssaop.OpSetLoUint32x16:
- return rewriteValueAMD64_OpSetLoUint32x16(v)
+ return rewriteValue_OpSetLoUint32x16(v)
case ssaop.OpSetLoUint32x8:
- return rewriteValueAMD64_OpSetLoUint32x8(v)
+ return rewriteValue_OpSetLoUint32x8(v)
case ssaop.OpSetLoUint64x4:
- return rewriteValueAMD64_OpSetLoUint64x4(v)
+ return rewriteValue_OpSetLoUint64x4(v)
case ssaop.OpSetLoUint64x8:
- return rewriteValueAMD64_OpSetLoUint64x8(v)
+ return rewriteValue_OpSetLoUint64x8(v)
case ssaop.OpSetLoUint8x32:
- return rewriteValueAMD64_OpSetLoUint8x32(v)
+ return rewriteValue_OpSetLoUint8x32(v)
case ssaop.OpSetLoUint8x64:
- return rewriteValueAMD64_OpSetLoUint8x64(v)
+ return rewriteValue_OpSetLoUint8x64(v)
case ssaop.OpShiftAllLeftConcatMod16Int16x16:
v.Op = ssaop.OpAMD64VPSHLDW256
return true
@@ -6737,11 +6737,11 @@
v.Op = ssaop.OpAMD64MOVBQSX
return true
case ssaop.OpSlicemask:
- return rewriteValueAMD64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSpectreIndex:
- return rewriteValueAMD64_OpSpectreIndex(v)
+ return rewriteValue_OpSpectreIndex(v)
case ssaop.OpSpectreSliceIndex:
- return rewriteValueAMD64_OpSpectreSliceIndex(v)
+ return rewriteValue_OpSpectreSliceIndex(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpAMD64SQRTSD
return true
@@ -6770,15 +6770,15 @@
v.Op = ssaop.OpAMD64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValueAMD64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpStoreMasked16:
- return rewriteValueAMD64_OpStoreMasked16(v)
+ return rewriteValue_OpStoreMasked16(v)
case ssaop.OpStoreMasked32:
- return rewriteValueAMD64_OpStoreMasked32(v)
+ return rewriteValue_OpStoreMasked32(v)
case ssaop.OpStoreMasked64:
- return rewriteValueAMD64_OpStoreMasked64(v)
+ return rewriteValue_OpStoreMasked64(v)
case ssaop.OpStoreMasked8:
- return rewriteValueAMD64_OpStoreMasked8(v)
+ return rewriteValue_OpStoreMasked8(v)
case ssaop.OpSub16:
v.Op = ssaop.OpAMD64SUBL
return true
@@ -6942,7 +6942,7 @@
v.Op = ssaop.OpAMD64CALLtailinter
return true
case ssaop.OpTrunc:
- return rewriteValueAMD64_OpTrunc(v)
+ return rewriteValue_OpTrunc(v)
case ssaop.OpTrunc16to8:
v.Op = ssaop.OpCopy
return true
@@ -6962,37 +6962,37 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpTruncFloat32x4:
- return rewriteValueAMD64_OpTruncFloat32x4(v)
+ return rewriteValue_OpTruncFloat32x4(v)
case ssaop.OpTruncFloat32x8:
- return rewriteValueAMD64_OpTruncFloat32x8(v)
+ return rewriteValue_OpTruncFloat32x8(v)
case ssaop.OpTruncFloat64x2:
- return rewriteValueAMD64_OpTruncFloat64x2(v)
+ return rewriteValue_OpTruncFloat64x2(v)
case ssaop.OpTruncFloat64x4:
- return rewriteValueAMD64_OpTruncFloat64x4(v)
+ return rewriteValue_OpTruncFloat64x4(v)
case ssaop.OpTruncScaledFloat32x16:
- return rewriteValueAMD64_OpTruncScaledFloat32x16(v)
+ return rewriteValue_OpTruncScaledFloat32x16(v)
case ssaop.OpTruncScaledFloat32x4:
- return rewriteValueAMD64_OpTruncScaledFloat32x4(v)
+ return rewriteValue_OpTruncScaledFloat32x4(v)
case ssaop.OpTruncScaledFloat32x8:
- return rewriteValueAMD64_OpTruncScaledFloat32x8(v)
+ return rewriteValue_OpTruncScaledFloat32x8(v)
case ssaop.OpTruncScaledFloat64x2:
- return rewriteValueAMD64_OpTruncScaledFloat64x2(v)
+ return rewriteValue_OpTruncScaledFloat64x2(v)
case ssaop.OpTruncScaledFloat64x4:
- return rewriteValueAMD64_OpTruncScaledFloat64x4(v)
+ return rewriteValue_OpTruncScaledFloat64x4(v)
case ssaop.OpTruncScaledFloat64x8:
- return rewriteValueAMD64_OpTruncScaledFloat64x8(v)
+ return rewriteValue_OpTruncScaledFloat64x8(v)
case ssaop.OpTruncScaledResidueFloat32x16:
- return rewriteValueAMD64_OpTruncScaledResidueFloat32x16(v)
+ return rewriteValue_OpTruncScaledResidueFloat32x16(v)
case ssaop.OpTruncScaledResidueFloat32x4:
- return rewriteValueAMD64_OpTruncScaledResidueFloat32x4(v)
+ return rewriteValue_OpTruncScaledResidueFloat32x4(v)
case ssaop.OpTruncScaledResidueFloat32x8:
- return rewriteValueAMD64_OpTruncScaledResidueFloat32x8(v)
+ return rewriteValue_OpTruncScaledResidueFloat32x8(v)
case ssaop.OpTruncScaledResidueFloat64x2:
- return rewriteValueAMD64_OpTruncScaledResidueFloat64x2(v)
+ return rewriteValue_OpTruncScaledResidueFloat64x2(v)
case ssaop.OpTruncScaledResidueFloat64x4:
- return rewriteValueAMD64_OpTruncScaledResidueFloat64x4(v)
+ return rewriteValue_OpTruncScaledResidueFloat64x4(v)
case ssaop.OpTruncScaledResidueFloat64x8:
- return rewriteValueAMD64_OpTruncScaledResidueFloat64x8(v)
+ return rewriteValue_OpTruncScaledResidueFloat64x8(v)
case ssaop.OpTruncToInt16Int32x16:
v.Op = ssaop.OpAMD64VPMOVDW256
return true
@@ -7189,7 +7189,7 @@
v.Op = ssaop.OpAMD64VPXORD512
return true
case ssaop.OpZero:
- return rewriteValueAMD64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpAMD64MOVWQZX
return true
@@ -7209,7 +7209,7 @@
v.Op = ssaop.OpAMD64MOVBQZX
return true
case ssaop.OpZeroSIMD:
- return rewriteValueAMD64_OpZeroSIMD(v)
+ return rewriteValue_OpZeroSIMD(v)
case ssaop.OpblendInt8x16:
v.Op = ssaop.OpAMD64VPBLENDVB128
return true
@@ -7217,13 +7217,13 @@
v.Op = ssaop.OpAMD64VPBLENDVB256
return true
case ssaop.OpblendMaskedInt16x32:
- return rewriteValueAMD64_OpblendMaskedInt16x32(v)
+ return rewriteValue_OpblendMaskedInt16x32(v)
case ssaop.OpblendMaskedInt32x16:
- return rewriteValueAMD64_OpblendMaskedInt32x16(v)
+ return rewriteValue_OpblendMaskedInt32x16(v)
case ssaop.OpblendMaskedInt64x8:
- return rewriteValueAMD64_OpblendMaskedInt64x8(v)
+ return rewriteValue_OpblendMaskedInt64x8(v)
case ssaop.OpblendMaskedInt8x64:
- return rewriteValueAMD64_OpblendMaskedInt8x64(v)
+ return rewriteValue_OpblendMaskedInt8x64(v)
case ssaop.Opbroadcast1To16Float32x4:
v.Op = ssaop.OpAMD64VBROADCASTSS512
return true
@@ -7237,19 +7237,19 @@
v.Op = ssaop.OpAMD64VPBROADCASTB128
return true
case ssaop.Opbroadcast1To16MaskedFloat32x4:
- return rewriteValueAMD64_Opbroadcast1To16MaskedFloat32x4(v)
+ return rewriteValue_Opbroadcast1To16MaskedFloat32x4(v)
case ssaop.Opbroadcast1To16MaskedInt16x8:
- return rewriteValueAMD64_Opbroadcast1To16MaskedInt16x8(v)
+ return rewriteValue_Opbroadcast1To16MaskedInt16x8(v)
case ssaop.Opbroadcast1To16MaskedInt32x4:
- return rewriteValueAMD64_Opbroadcast1To16MaskedInt32x4(v)
+ return rewriteValue_Opbroadcast1To16MaskedInt32x4(v)
case ssaop.Opbroadcast1To16MaskedInt8x16:
- return rewriteValueAMD64_Opbroadcast1To16MaskedInt8x16(v)
+ return rewriteValue_Opbroadcast1To16MaskedInt8x16(v)
case ssaop.Opbroadcast1To16MaskedUint16x8:
- return rewriteValueAMD64_Opbroadcast1To16MaskedUint16x8(v)
+ return rewriteValue_Opbroadcast1To16MaskedUint16x8(v)
case ssaop.Opbroadcast1To16MaskedUint32x4:
- return rewriteValueAMD64_Opbroadcast1To16MaskedUint32x4(v)
+ return rewriteValue_Opbroadcast1To16MaskedUint32x4(v)
case ssaop.Opbroadcast1To16MaskedUint8x16:
- return rewriteValueAMD64_Opbroadcast1To16MaskedUint8x16(v)
+ return rewriteValue_Opbroadcast1To16MaskedUint8x16(v)
case ssaop.Opbroadcast1To16Uint16x8:
v.Op = ssaop.OpAMD64VPBROADCASTW256
return true
@@ -7266,11 +7266,11 @@
v.Op = ssaop.OpAMD64VPBROADCASTQ128
return true
case ssaop.Opbroadcast1To2MaskedFloat64x2:
- return rewriteValueAMD64_Opbroadcast1To2MaskedFloat64x2(v)
+ return rewriteValue_Opbroadcast1To2MaskedFloat64x2(v)
case ssaop.Opbroadcast1To2MaskedInt64x2:
- return rewriteValueAMD64_Opbroadcast1To2MaskedInt64x2(v)
+ return rewriteValue_Opbroadcast1To2MaskedInt64x2(v)
case ssaop.Opbroadcast1To2MaskedUint64x2:
- return rewriteValueAMD64_Opbroadcast1To2MaskedUint64x2(v)
+ return rewriteValue_Opbroadcast1To2MaskedUint64x2(v)
case ssaop.Opbroadcast1To2Uint64x2:
v.Op = ssaop.OpAMD64VPBROADCASTQ128
return true
@@ -7281,13 +7281,13 @@
v.Op = ssaop.OpAMD64VPBROADCASTB256
return true
case ssaop.Opbroadcast1To32MaskedInt16x8:
- return rewriteValueAMD64_Opbroadcast1To32MaskedInt16x8(v)
+ return rewriteValue_Opbroadcast1To32MaskedInt16x8(v)
case ssaop.Opbroadcast1To32MaskedInt8x16:
- return rewriteValueAMD64_Opbroadcast1To32MaskedInt8x16(v)
+ return rewriteValue_Opbroadcast1To32MaskedInt8x16(v)
case ssaop.Opbroadcast1To32MaskedUint16x8:
- return rewriteValueAMD64_Opbroadcast1To32MaskedUint16x8(v)
+ return rewriteValue_Opbroadcast1To32MaskedUint16x8(v)
case ssaop.Opbroadcast1To32MaskedUint8x16:
- return rewriteValueAMD64_Opbroadcast1To32MaskedUint8x16(v)
+ return rewriteValue_Opbroadcast1To32MaskedUint8x16(v)
case ssaop.Opbroadcast1To32Uint16x8:
v.Op = ssaop.OpAMD64VPBROADCASTW512
return true
@@ -7307,17 +7307,17 @@
v.Op = ssaop.OpAMD64VPBROADCASTQ256
return true
case ssaop.Opbroadcast1To4MaskedFloat32x4:
- return rewriteValueAMD64_Opbroadcast1To4MaskedFloat32x4(v)
+ return rewriteValue_Opbroadcast1To4MaskedFloat32x4(v)
case ssaop.Opbroadcast1To4MaskedFloat64x2:
- return rewriteValueAMD64_Opbroadcast1To4MaskedFloat64x2(v)
+ return rewriteValue_Opbroadcast1To4MaskedFloat64x2(v)
case ssaop.Opbroadcast1To4MaskedInt32x4:
- return rewriteValueAMD64_Opbroadcast1To4MaskedInt32x4(v)
+ return rewriteValue_Opbroadcast1To4MaskedInt32x4(v)
case ssaop.Opbroadcast1To4MaskedInt64x2:
- return rewriteValueAMD64_Opbroadcast1To4MaskedInt64x2(v)
+ return rewriteValue_Opbroadcast1To4MaskedInt64x2(v)
case ssaop.Opbroadcast1To4MaskedUint32x4:
- return rewriteValueAMD64_Opbroadcast1To4MaskedUint32x4(v)
+ return rewriteValue_Opbroadcast1To4MaskedUint32x4(v)
case ssaop.Opbroadcast1To4MaskedUint64x2:
- return rewriteValueAMD64_Opbroadcast1To4MaskedUint64x2(v)
+ return rewriteValue_Opbroadcast1To4MaskedUint64x2(v)
case ssaop.Opbroadcast1To4Uint32x4:
v.Op = ssaop.OpAMD64VPBROADCASTD128
return true
@@ -7328,9 +7328,9 @@
v.Op = ssaop.OpAMD64VPBROADCASTB512
return true
case ssaop.Opbroadcast1To64MaskedInt8x16:
- return rewriteValueAMD64_Opbroadcast1To64MaskedInt8x16(v)
+ return rewriteValue_Opbroadcast1To64MaskedInt8x16(v)
case ssaop.Opbroadcast1To64MaskedUint8x16:
- return rewriteValueAMD64_Opbroadcast1To64MaskedUint8x16(v)
+ return rewriteValue_Opbroadcast1To64MaskedUint8x16(v)
case ssaop.Opbroadcast1To64Uint8x16:
v.Op = ssaop.OpAMD64VPBROADCASTB512
return true
@@ -7350,21 +7350,21 @@
v.Op = ssaop.OpAMD64VPBROADCASTQ512
return true
case ssaop.Opbroadcast1To8MaskedFloat32x4:
- return rewriteValueAMD64_Opbroadcast1To8MaskedFloat32x4(v)
+ return rewriteValue_Opbroadcast1To8MaskedFloat32x4(v)
case ssaop.Opbroadcast1To8MaskedFloat64x2:
- return rewriteValueAMD64_Opbroadcast1To8MaskedFloat64x2(v)
+ return rewriteValue_Opbroadcast1To8MaskedFloat64x2(v)
case ssaop.Opbroadcast1To8MaskedInt16x8:
- return rewriteValueAMD64_Opbroadcast1To8MaskedInt16x8(v)
+ return rewriteValue_Opbroadcast1To8MaskedInt16x8(v)
case ssaop.Opbroadcast1To8MaskedInt32x4:
- return rewriteValueAMD64_Opbroadcast1To8MaskedInt32x4(v)
+ return rewriteValue_Opbroadcast1To8MaskedInt32x4(v)
case ssaop.Opbroadcast1To8MaskedInt64x2:
- return rewriteValueAMD64_Opbroadcast1To8MaskedInt64x2(v)
+ return rewriteValue_Opbroadcast1To8MaskedInt64x2(v)
case ssaop.Opbroadcast1To8MaskedUint16x8:
- return rewriteValueAMD64_Opbroadcast1To8MaskedUint16x8(v)
+ return rewriteValue_Opbroadcast1To8MaskedUint16x8(v)
case ssaop.Opbroadcast1To8MaskedUint32x4:
- return rewriteValueAMD64_Opbroadcast1To8MaskedUint32x4(v)
+ return rewriteValue_Opbroadcast1To8MaskedUint32x4(v)
case ssaop.Opbroadcast1To8MaskedUint64x2:
- return rewriteValueAMD64_Opbroadcast1To8MaskedUint64x2(v)
+ return rewriteValue_Opbroadcast1To8MaskedUint64x2(v)
case ssaop.Opbroadcast1To8Uint16x8:
v.Op = ssaop.OpAMD64VPBROADCASTW128
return true
@@ -7530,7 +7530,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADCQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADCQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7592,7 +7592,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADCQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADCQconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7634,7 +7634,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDBconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDBconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDBconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -7682,7 +7682,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDL (SHRLconst [1] x) (SHRLconst [1] x))
@@ -7869,7 +7869,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDLconst [c] (ADDL x y))
// result: (LEAL1 [c] x y)
@@ -8056,7 +8056,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -8104,7 +8104,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8177,7 +8177,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDLlock(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8237,7 +8237,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8288,7 +8288,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8520,7 +8520,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQcarry(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQcarry(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDQcarry x (MOVQconst [c]))
@@ -8545,7 +8545,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDQconst [c] (ADDQ x y))
// result: (LEAQ1 [c] x y)
@@ -8736,7 +8736,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -8784,7 +8784,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8857,7 +8857,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQlock(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8917,7 +8917,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDQmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8968,7 +8968,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSD(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -9018,7 +9018,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSDload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9091,7 +9091,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -9141,7 +9141,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSSload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9214,7 +9214,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDWconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ADDWconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDWconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -9262,7 +9262,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDBconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDBconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDBconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -9310,7 +9310,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9444,7 +9444,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDLconst [c] (ANDLconst [d] x))
// result: (ANDLconst [c & d] x)
@@ -9516,7 +9516,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -9564,7 +9564,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9637,7 +9637,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9688,7 +9688,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDNL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDNL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDNL x (SHLL (MOVLconst [1]) y))
@@ -9709,7 +9709,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDNQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDNQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDNQ x (SHLQ (MOVQconst [1]) y))
@@ -9730,7 +9730,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9888,7 +9888,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDQconst [c] (ANDQconst [d] x))
// result: (ANDQconst [c & d] x)
@@ -9960,7 +9960,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDQconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -10008,7 +10008,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10081,7 +10081,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDQmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10132,7 +10132,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDWconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ANDWconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDWconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -10180,7 +10180,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64AddTupleFirst32(v *ssa.Value) bool {
+func rewriteValue_OpAMD64AddTupleFirst32(v *ssa.Value) bool {
// match: (AddTupleFirst32 _ _)
// cond: v.Uses == 0
// result: (Invalid)
@@ -10193,7 +10193,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64AddTupleFirst64(v *ssa.Value) bool {
+func rewriteValue_OpAMD64AddTupleFirst64(v *ssa.Value) bool {
// match: (AddTupleFirst64 _ _)
// cond: v.Uses == 0
// result: (Invalid)
@@ -10206,7 +10206,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BSFQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BSFQ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x)))
@@ -10255,7 +10255,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BSWAPL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BSWAPL(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10317,7 +10317,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BSWAPQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BSWAPQ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10379,7 +10379,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BTCQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BTCQconst [c] (MOVQconst [d]))
// result: (MOVQconst [d^(1<<uint32(c))])
@@ -10395,7 +10395,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BTLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BTLconst [c] (SHRQconst [d] x))
// cond: (c+d)<64
@@ -10553,7 +10553,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BTQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BTQconst [c] (SHRQconst [d] x))
// cond: (c+d)<64
@@ -10626,7 +10626,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BTRQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BTRQconst [c] (BTSQconst [c] x))
// result: (BTRQconst [c] x)
@@ -10668,7 +10668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64BTSQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BTSQconst [c] (BTRQconst [c] x))
// result: (BTSQconst [c] x)
@@ -10710,7 +10710,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLCC(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLCC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10779,7 +10779,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLCS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLCS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10848,7 +10848,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLEQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLEQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12214,7 +12214,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLGE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLGE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12326,7 +12326,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLGT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLGT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12395,7 +12395,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLHI(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLHI(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12464,7 +12464,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLLE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12533,7 +12533,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLLS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12602,7 +12602,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLLT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12714,7 +12714,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLNE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVLNE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14576,7 +14576,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQCC(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQCC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14645,7 +14645,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQCS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQCS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14714,7 +14714,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQEQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQEQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16126,7 +16126,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQGE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQGE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16238,7 +16238,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQGT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQGT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16307,7 +16307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQHI(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQHI(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16376,7 +16376,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQLE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16445,7 +16445,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQLS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16514,7 +16514,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQLT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16626,7 +16626,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQNE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVQNE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18488,7 +18488,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWCC(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWCC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18557,7 +18557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWCS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWCS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18626,7 +18626,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWEQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWEQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19935,7 +19935,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWGE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWGE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20004,7 +20004,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWGT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWGT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20073,7 +20073,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWHI(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWHI(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20142,7 +20142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWLE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20211,7 +20211,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWLS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20280,7 +20280,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLT(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWLT(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20349,7 +20349,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWNE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMOVWNE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22154,7 +22154,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22249,7 +22249,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPBconst (MOVLconst [x]) [y])
@@ -22420,7 +22420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPBconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -22468,7 +22468,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22536,7 +22536,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22631,7 +22631,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPLconst (MOVLconst [x]) [y])
@@ -22817,7 +22817,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPLconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -22865,7 +22865,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22933,7 +22933,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23126,7 +23126,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPQconst (MOVQconst [x]) [y])
@@ -23349,7 +23349,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPQconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -23397,7 +23397,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23469,7 +23469,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23564,7 +23564,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPWconst (MOVLconst [x]) [y])
@@ -23735,7 +23735,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPWconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -23783,7 +23783,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23851,7 +23851,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPXCHGLlock(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -23881,7 +23881,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPXCHGQlock(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -23911,7 +23911,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CVTSD2SS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CVTSD2SS(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CVTSD2SS (ROUNDSD [c] (CVTSS2SD x)))
// result: (ROUNDSS [c] x)
@@ -23932,7 +23932,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSD(v *ssa.Value) bool {
+func rewriteValue_OpAMD64DIVSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -23959,7 +23959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSDload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64DIVSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -24010,7 +24010,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64DIVSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -24037,7 +24037,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSSload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64DIVSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -24088,7 +24088,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64HMULL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULL x y)
@@ -24106,7 +24106,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULLU(v *ssa.Value) bool {
+func rewriteValue_OpAMD64HMULLU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULLU x y)
@@ -24124,7 +24124,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64HMULQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULQ x y)
@@ -24142,7 +24142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULQU(v *ssa.Value) bool {
+func rewriteValue_OpAMD64HMULQU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULQU x y)
@@ -24160,7 +24160,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KANDB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KANDB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (KANDB (VCMPPD512 [3] x x) (VCMPPD512 [3] y y))
@@ -24184,7 +24184,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KANDW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KANDW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (KANDW (VCMPPS512 [3] x x) (VCMPPS512 [3] y y))
@@ -24208,7 +24208,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KMOVBk(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KMOVBk(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (KMOVBk l:(MOVBload [off] {sym} ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -24233,7 +24233,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KMOVDk(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KMOVDk(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (KMOVDk l:(MOVLload [off] {sym} ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -24258,7 +24258,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KMOVQk(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KMOVQk(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (KMOVQk l:(MOVQload [off] {sym} ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -24283,7 +24283,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64KMOVWk(v *ssa.Value) bool {
+func rewriteValue_OpAMD64KMOVWk(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (KMOVWk l:(MOVWload [off] {sym} ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -24308,7 +24308,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: ssa.Is32Bit(int64(c)+int64(d))
@@ -24358,7 +24358,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAL1(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
@@ -24449,7 +24449,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL2(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAL2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
@@ -24553,7 +24553,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL4(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAL4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
@@ -24621,7 +24621,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL8(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAL8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
@@ -24668,7 +24668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAQ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LEAQ [c] {s} (ADDQconst [d] x))
// cond: ssa.Is32Bit(int64(c)+int64(d))
@@ -24827,7 +24827,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAQ1(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
@@ -25017,7 +25017,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ2(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAQ2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
@@ -25205,7 +25205,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ4(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAQ4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
@@ -25357,7 +25357,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ8(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LEAQ8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
@@ -25466,7 +25466,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVQconst [c]) mem)
@@ -25487,7 +25487,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVQconst [c]) mem)
@@ -25508,7 +25508,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpAMD64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25546,7 +25546,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBELstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBELstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25574,7 +25574,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBEQstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBEQstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25602,7 +25602,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBEWstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBEWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25630,7 +25630,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBQSX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem))
@@ -25755,7 +25755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSXload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBQSXload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBQSXload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
@@ -25816,7 +25816,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem))
@@ -25937,7 +25937,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBatomicload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBatomicload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -25985,7 +25985,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
@@ -26067,7 +26067,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -26531,7 +26531,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -26579,7 +26579,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLQSX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem))
@@ -26680,7 +26680,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSXload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLQSXload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26743,7 +26743,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem))
@@ -26840,7 +26840,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLatomicload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLatomicload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -26888,7 +26888,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLf2i(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLf2i(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLf2i <t> (Arg <u> [off] {sym}))
@@ -26914,7 +26914,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLi2f(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLi2f(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLi2f <t> (Arg <u> [off] {sym}))
@@ -26940,7 +26940,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27056,7 +27056,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -27593,7 +27593,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -27641,7 +27641,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVOload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -27689,7 +27689,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVOstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -27777,7 +27777,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVOstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVOstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -27825,7 +27825,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQatomicload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQatomicload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -27873,7 +27873,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQf2i(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQf2i(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVQf2i <t> (Arg <u> [off] {sym}))
@@ -27899,7 +27899,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQi2f(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQi2f(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVQi2f <t> (Arg <u> [off] {sym}))
@@ -27925,7 +27925,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28025,7 +28025,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -28593,7 +28593,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVQstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -28693,7 +28693,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVSDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -28758,7 +28758,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVSDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -28851,7 +28851,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVSSload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -28916,7 +28916,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVSSstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29009,7 +29009,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWQSX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem))
@@ -29122,7 +29122,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSXload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWQSXload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -29185,7 +29185,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem))
@@ -29294,7 +29294,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -29378,7 +29378,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29644,7 +29644,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -29692,7 +29692,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULL x (MOVLconst [c]))
@@ -29713,7 +29713,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -29777,7 +29777,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULQ x (MOVQconst [c]))
@@ -29802,7 +29802,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -29887,7 +29887,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSD(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -29917,7 +29917,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSDload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29990,7 +29990,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -30020,7 +30020,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSSload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MULSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30093,7 +30093,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64NEGL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGL (NEGL x))
// result: x
@@ -30135,7 +30135,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64NEGQ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGQ (NEGQ x))
// result: x
@@ -30198,7 +30198,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64NOTL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NOTL (MOVLconst [c]))
// result: (MOVLconst [^c])
@@ -30213,7 +30213,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64NOTQ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NOTQ (MOVQconst [c]))
// result: (MOVQconst [^c])
@@ -30228,7 +30228,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORBconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORBconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORBconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -30276,7 +30276,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORL (SHLL (MOVLconst [1]) y) x)
@@ -30351,7 +30351,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORLconst [c] (ORLconst [d] x))
// result: (ORLconst [c | d] x)
@@ -30401,7 +30401,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -30449,7 +30449,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30522,7 +30522,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30573,7 +30573,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORQ (SHLQ (MOVQconst [1]) y) x)
@@ -30706,7 +30706,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORQconst [c] (ORQconst [d] x))
// result: (ORQconst [c | d] x)
@@ -30756,7 +30756,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORQconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -30804,7 +30804,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30877,7 +30877,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORQmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30928,7 +30928,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORWconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ORWconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORWconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -30976,7 +30976,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLB x (NEGQ y))
@@ -31031,7 +31031,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLBconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLBconst x [0])
// result: x
@@ -31045,7 +31045,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLL x (NEGQ y))
@@ -31100,7 +31100,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLLconst x [0])
// result: x
@@ -31114,7 +31114,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLQ x (NEGQ y))
@@ -31169,7 +31169,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLQconst x [0])
// result: x
@@ -31183,7 +31183,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLW x (NEGQ y))
@@ -31238,7 +31238,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLWconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64ROLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROLWconst x [0])
// result: x
@@ -31252,7 +31252,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64RORB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORB x (NEGQ y))
@@ -31307,7 +31307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64RORL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORL x (NEGQ y))
@@ -31362,7 +31362,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64RORQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORQ x (NEGQ y))
@@ -31417,7 +31417,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64RORW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORW x (NEGQ y))
@@ -31472,7 +31472,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARB x (MOVQconst [c]))
@@ -31503,7 +31503,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARBconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARBconst x [0])
// result: x
@@ -31529,7 +31529,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31747,7 +31747,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARLconst x [0])
// result: x
@@ -31773,7 +31773,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31991,7 +31991,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARQconst x [0])
// result: x
@@ -32017,7 +32017,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARW x (MOVQconst [c]))
@@ -32048,7 +32048,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARWconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SARWconst x [0])
// result: x
@@ -32074,7 +32074,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARXLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARXLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32102,7 +32102,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARXQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARXQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32150,7 +32150,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SBBLcarrymask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SBBLcarrymask (FlagEQ))
// result: (MOVLconst [0])
@@ -32204,7 +32204,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SBBQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32263,7 +32263,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SBBQcarrymask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SBBQcarrymask (FlagEQ))
// result: (MOVQconst [0])
@@ -32317,7 +32317,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SBBQconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32359,7 +32359,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETA(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETA(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETA (InvertFlags x))
// result: (SETB x)
@@ -32424,7 +32424,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETAE(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -32615,7 +32615,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAEstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETAEstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32775,7 +32775,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETAstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32935,7 +32935,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETB(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETB (TESTQ x x))
@@ -33119,7 +33119,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETBE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETBE (InvertFlags x))
// result: (SETAE x)
@@ -33184,7 +33184,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBEstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETBEstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33344,7 +33344,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33504,7 +33504,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETEQ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETEQ (TESTL (SHLL (MOVLconst [1]) x) y))
@@ -35310,7 +35310,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETEQstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -35892,7 +35892,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETG(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETG (InvertFlags x))
// result: (SETL x)
@@ -35957,7 +35957,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETGE(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETGE c:(CMPQconst [128] x))
@@ -36061,7 +36061,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGEstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETGEstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -36221,7 +36221,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETGstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -36381,7 +36381,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETL(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETL c:(CMPQconst [128] x))
@@ -36485,7 +36485,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETLE(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SETLE (InvertFlags x))
// result: (SETGE x)
@@ -36550,7 +36550,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLEstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETLEstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -36710,7 +36710,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETLstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -36870,7 +36870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNE(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETNE(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETNE (TESTBconst [1] x))
@@ -38868,7 +38868,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNEstore(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SETNEstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -39450,7 +39450,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39668,7 +39668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHLLconst x [0])
// result: x
@@ -39722,7 +39722,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39940,7 +39940,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHLQconst x [0])
// result: x
@@ -40006,7 +40006,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLXLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLXLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40034,7 +40034,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLXQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLXQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40082,7 +40082,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRB x (MOVQconst [c]))
@@ -40151,7 +40151,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRBconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRBconst x [0])
// result: x
@@ -40165,7 +40165,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40383,7 +40383,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRLconst [1] (ADDL x x))
// result: (ANDLconst [0x7fffffff] x)
@@ -40412,7 +40412,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40630,7 +40630,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRQconst [1] (ADDQ x x))
// result: (BTRQconst [63] x)
@@ -40659,7 +40659,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRW x (MOVQconst [c]))
@@ -40728,7 +40728,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRWconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SHRWconst x [0])
// result: x
@@ -40742,7 +40742,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRXLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRXLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40770,7 +40770,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRXQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRXQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40818,7 +40818,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40885,7 +40885,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBLconst [0] x)
// result: x
@@ -40908,7 +40908,7 @@
return true
}
}
-func rewriteValueAMD64_OpAMD64SUBLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40981,7 +40981,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -41032,7 +41032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -41127,7 +41127,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQborrow(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBQborrow(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBQborrow x (MOVQconst [c]))
@@ -41149,7 +41149,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBQconst [0] x)
// result: x
@@ -41207,7 +41207,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -41280,7 +41280,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBQmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -41331,7 +41331,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSD(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBSD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -41398,7 +41398,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSDload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBSDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -41471,7 +41471,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSS(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBSS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -41538,7 +41538,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSSload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SUBSSload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -41611,7 +41611,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTB(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -41660,7 +41660,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTBconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TESTBconst [-1] x)
// cond: x.Op != ssaop.OpAMD64MOVLconst
@@ -41679,7 +41679,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -41755,7 +41755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TESTLconst [c] (MOVLconst [c]))
// cond: c == 0
@@ -41807,7 +41807,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -41887,7 +41887,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TESTQconst [c] (MOVQconst [d]))
// cond: int64(c) == d && c == 0
@@ -41951,7 +41951,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTW(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -42000,7 +42000,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTWconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64TESTWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TESTWconst [-1] x)
// cond: x.Op != ssaop.OpAMD64MOVLconst
@@ -42019,7 +42019,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42049,7 +42049,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42079,7 +42079,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -42109,7 +42109,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42141,7 +42141,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42173,7 +42173,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42205,7 +42205,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42235,7 +42235,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42265,7 +42265,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -42295,7 +42295,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42327,7 +42327,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42359,7 +42359,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -42391,7 +42391,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDSUBPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDSUBPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDSUBPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42418,7 +42418,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDSUBPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDSUBPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDSUBPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42445,7 +42445,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDSUBPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDSUBPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDSUBPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42472,7 +42472,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VADDSUBPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VADDSUBPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VADDSUBPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42499,7 +42499,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESDEC128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESDEC128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESDEC128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42526,7 +42526,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESDEC256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESDEC256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESDEC256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42553,7 +42553,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESDECLAST128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESDECLAST128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESDECLAST128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42580,7 +42580,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESDECLAST256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESDECLAST256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESDECLAST256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42607,7 +42607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESENC128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESENC128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESENC128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42634,7 +42634,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESENC256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESENC256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESENC256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42661,7 +42661,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESENCLAST128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESENCLAST128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESENCLAST128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -42688,7 +42688,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESENCLAST256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESENCLAST256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VAESENCLAST256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -42715,7 +42715,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESIMC128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESIMC128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VAESIMC128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42740,7 +42740,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VAESKEYGENASSIST128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VAESKEYGENASSIST128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VAESKEYGENASSIST128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42766,7 +42766,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VBROADCASTSD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: v.Block.CPUfeatures.HasFeature(ssa.CPUavx) && ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42791,7 +42791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VBROADCASTSD512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42816,7 +42816,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VBROADCASTSDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -42843,7 +42843,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VBROADCASTSDMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -42870,7 +42870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VBROADCASTSS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: v.Block.CPUfeatures.HasFeature(ssa.CPUavx) && ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42895,7 +42895,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VBROADCASTSS256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: v.Block.CPUfeatures.HasFeature(ssa.CPUavx) && ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42920,7 +42920,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VBROADCASTSS512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -42945,7 +42945,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VBROADCASTSSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -42972,7 +42972,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VBROADCASTSSMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -42999,7 +42999,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VBROADCASTSSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VBROADCASTSSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VBROADCASTSSMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43026,7 +43026,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -43054,7 +43054,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -43082,7 +43082,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -43110,7 +43110,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43140,7 +43140,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43170,7 +43170,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43200,7 +43200,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPS128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -43228,7 +43228,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPS256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -43256,7 +43256,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCMPPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -43284,7 +43284,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43314,7 +43314,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43344,7 +43344,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCMPPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCMPPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -43374,7 +43374,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTDQ2PD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43399,7 +43399,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTDQ2PD512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43424,7 +43424,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTDQ2PDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43451,7 +43451,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTDQ2PDMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -43478,7 +43478,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTDQ2PS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43503,7 +43503,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTDQ2PS256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43528,7 +43528,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTDQ2PS512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43553,7 +43553,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTDQ2PSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43580,7 +43580,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTDQ2PSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -43607,7 +43607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTDQ2PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTDQ2PSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTDQ2PSMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -43634,7 +43634,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTPD2PS256 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43659,7 +43659,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTPD2PSMasked256 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -43686,7 +43686,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PSX128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PSX128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTPD2PSX128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43711,7 +43711,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PSXMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PSXMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTPD2PSXMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43738,7 +43738,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PSY128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PSY128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTPD2PSY128 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43763,7 +43763,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPD2PSYMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPD2PSYMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTPD2PSYMasked128 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -43790,7 +43790,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPS2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPS2PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTPS2PD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43815,7 +43815,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPS2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPS2PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTPS2PD512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43840,7 +43840,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPS2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPS2PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTPS2PDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43867,7 +43867,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTPS2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTPS2PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTPS2PDMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -43894,7 +43894,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43919,7 +43919,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43944,7 +43944,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -43969,7 +43969,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -43996,7 +43996,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44023,7 +44023,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44050,7 +44050,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PS256 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44075,7 +44075,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PSMasked256 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44102,7 +44102,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PSX128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PSX128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PSX128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44127,7 +44127,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PSXMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PSXMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PSXMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44154,7 +44154,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PSY128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PSY128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTQQ2PSY128 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44179,7 +44179,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTQQ2PSYMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTQQ2PSYMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTQQ2PSYMasked128 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44206,7 +44206,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2DQ256 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44231,7 +44231,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2DQMasked256 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44258,7 +44258,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQX128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQX128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2DQX128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44283,7 +44283,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQXMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQXMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2DQXMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44310,7 +44310,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQY128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQY128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2DQY128 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44335,7 +44335,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2DQYMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2DQYMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2DQYMasked128 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44362,7 +44362,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2QQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44387,7 +44387,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2QQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44412,7 +44412,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2QQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44437,7 +44437,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2QQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44464,7 +44464,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2QQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44491,7 +44491,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2QQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2QQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2QQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44518,7 +44518,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UDQ256 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44543,7 +44543,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UDQMasked256 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44570,7 +44570,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQX128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQX128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UDQX128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44595,7 +44595,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQXMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQXMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UDQXMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44622,7 +44622,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQY128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQY128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UDQY128 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44647,7 +44647,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UDQYMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UDQYMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UDQYMasked128 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44674,7 +44674,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UQQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44699,7 +44699,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UQQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44724,7 +44724,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPD2UQQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44749,7 +44749,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UQQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44776,7 +44776,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UQQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44803,7 +44803,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPD2UQQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPD2UQQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPD2UQQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44830,7 +44830,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2DQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44855,7 +44855,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2DQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44880,7 +44880,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2DQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -44905,7 +44905,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2DQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -44932,7 +44932,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2DQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -44959,7 +44959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2DQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2DQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2DQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -44986,7 +44986,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2QQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2QQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2QQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45011,7 +45011,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2QQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2QQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2QQ512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45036,7 +45036,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2QQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2QQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2QQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45063,7 +45063,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2QQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2QQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2QQMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45090,7 +45090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2UDQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45115,7 +45115,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2UDQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45140,7 +45140,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2UDQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45165,7 +45165,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2UDQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45192,7 +45192,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2UDQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45219,7 +45219,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UDQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2UDQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -45246,7 +45246,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UQQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UQQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2UQQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45271,7 +45271,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UQQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UQQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTTPS2UQQ512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45296,7 +45296,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UQQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UQQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2UQQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45323,7 +45323,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTTPS2UQQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTTPS2UQQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTTPS2UQQMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45350,7 +45350,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUDQ2PD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45375,7 +45375,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUDQ2PD512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45400,7 +45400,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUDQ2PDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45427,7 +45427,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUDQ2PDMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45454,7 +45454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUDQ2PS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45479,7 +45479,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUDQ2PS256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45504,7 +45504,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUDQ2PS512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45529,7 +45529,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUDQ2PSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45556,7 +45556,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUDQ2PSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45583,7 +45583,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUDQ2PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUDQ2PSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUDQ2PSMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -45610,7 +45610,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45635,7 +45635,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45660,7 +45660,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45685,7 +45685,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45712,7 +45712,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45739,7 +45739,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -45766,7 +45766,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PS256 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45791,7 +45791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PSMasked256 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -45818,7 +45818,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PSX128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PSX128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PSX128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45843,7 +45843,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PSXMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PSXMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PSXMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -45870,7 +45870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PSY128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PSY128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VCVTUQQ2PSY128 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -45895,7 +45895,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VCVTUQQ2PSYMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VCVTUQQ2PSYMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VCVTUQQ2PSYMasked128 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -45922,7 +45922,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -45949,7 +45949,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -45976,7 +45976,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -46003,7 +46003,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46032,7 +46032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46061,7 +46061,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46090,7 +46090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -46117,7 +46117,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -46144,7 +46144,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VDIVPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -46171,7 +46171,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46200,7 +46200,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46229,7 +46229,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VDIVPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VDIVPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46258,7 +46258,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VEXPANDPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VEXPANDPDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VEXPANDPDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -46285,7 +46285,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VEXPANDPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VEXPANDPDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VEXPANDPDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -46312,7 +46312,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VEXPANDPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VEXPANDPSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VEXPANDPSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -46339,7 +46339,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VEXPANDPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VEXPANDPSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VEXPANDPSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -46366,7 +46366,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46395,7 +46395,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46424,7 +46424,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46453,7 +46453,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46484,7 +46484,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46515,7 +46515,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46546,7 +46546,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PS128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46575,7 +46575,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PS256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46604,7 +46604,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PS512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46633,7 +46633,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PSMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46664,7 +46664,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PSMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46695,7 +46695,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADD213PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADD213PSMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46726,7 +46726,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46755,7 +46755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46784,7 +46784,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46813,7 +46813,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46844,7 +46844,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46875,7 +46875,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -46906,7 +46906,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PS128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46935,7 +46935,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PS256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46964,7 +46964,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PS512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -46993,7 +46993,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PSMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47024,7 +47024,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PSMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47055,7 +47055,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMADDSUB213PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMADDSUB213PSMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47086,7 +47086,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47115,7 +47115,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47144,7 +47144,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47173,7 +47173,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47204,7 +47204,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47235,7 +47235,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47266,7 +47266,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PS128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47295,7 +47295,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PS256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47324,7 +47324,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PS512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47353,7 +47353,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PSMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47384,7 +47384,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PSMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47415,7 +47415,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VFMSUBADD213PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VFMSUBADD213PSMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -47446,7 +47446,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEINVQB128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -47474,7 +47474,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEINVQB256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -47502,7 +47502,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQB512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEINVQB512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -47530,7 +47530,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47560,7 +47560,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47590,7 +47590,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEINVQBMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47620,7 +47620,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEQB128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -47648,7 +47648,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEQB256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -47676,7 +47676,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQB512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8AFFINEQB512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -47704,7 +47704,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47734,7 +47734,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47764,7 +47764,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8AFFINEQBMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47794,7 +47794,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8MULB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8MULB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8MULB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -47821,7 +47821,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8MULB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8MULB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VGF2P8MULB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -47848,7 +47848,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8MULBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8MULBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47877,7 +47877,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VGF2P8MULBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VGF2P8MULBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -47906,7 +47906,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHADDPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHADDPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHADDPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -47933,7 +47933,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHADDPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHADDPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHADDPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -47960,7 +47960,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHADDPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHADDPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHADDPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -47987,7 +47987,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHADDPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHADDPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHADDPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48014,7 +48014,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHSUBPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHSUBPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHSUBPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48041,7 +48041,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHSUBPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHSUBPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHSUBPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48068,7 +48068,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHSUBPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHSUBPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHSUBPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48095,7 +48095,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VHSUBPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VHSUBPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VHSUBPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48122,7 +48122,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VINSERTF128256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VINSERTF128256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VINSERTF128256 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48150,7 +48150,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VINSERTF64X4512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VINSERTF64X4512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VINSERTF64X4512 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48178,7 +48178,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VINSERTI128256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VINSERTI128256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VINSERTI128256 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48206,7 +48206,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VINSERTI64X4512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VINSERTI64X4512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VINSERTI64X4512 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48234,7 +48234,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48264,7 +48264,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48294,7 +48294,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -48324,7 +48324,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48356,7 +48356,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48388,7 +48388,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48420,7 +48420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48450,7 +48450,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48480,7 +48480,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMAXPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -48510,7 +48510,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48542,7 +48542,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48574,7 +48574,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMAXPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMAXPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48606,7 +48606,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48636,7 +48636,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48666,7 +48666,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -48696,7 +48696,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48728,7 +48728,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48760,7 +48760,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48792,7 +48792,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -48822,7 +48822,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -48852,7 +48852,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMINPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -48882,7 +48882,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48914,7 +48914,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48946,7 +48946,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMINPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMINPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -48978,7 +48978,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVD(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVD(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VMOVD x:(MOVLload [off] {sym} ptr mem))
@@ -49006,7 +49006,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU16Masked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU16Masked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU16Masked128 (VPABSW128 x) mask)
@@ -49560,7 +49560,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU16Masked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU16Masked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU16Masked256 (VPABSW256 x) mask)
@@ -50150,7 +50150,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU16Masked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU16Masked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU16Masked512 (VPABSW512 x) mask)
@@ -50668,7 +50668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU32Masked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU32Masked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU32Masked128 (VPABSD128 x) mask)
@@ -51389,7 +51389,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU32Masked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU32Masked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU32Masked256 (VPABSD256 x) mask)
@@ -52232,7 +52232,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU32Masked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU32Masked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU32Masked512 (VPABSD512 x) mask)
@@ -53079,7 +53079,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU64Masked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU64Masked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU64Masked128 (VPABSQ128 x) mask)
@@ -53916,7 +53916,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU64Masked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU64Masked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU64Masked256 (VPABSQ256 x) mask)
@@ -54755,7 +54755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU64Masked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU64Masked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU64Masked512 (VPABSQ512 x) mask)
@@ -55514,7 +55514,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU8Masked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU8Masked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU8Masked128 (VPABSB128 x) mask)
@@ -55856,7 +55856,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU8Masked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU8Masked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU8Masked256 (VPABSB256 x) mask)
@@ -56198,7 +56198,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU8Masked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQU8Masked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQU8Masked512 (VPABSB512 x) mask)
@@ -56540,7 +56540,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUload128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUload128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQUload128 [off1] {sym} x:(ADDQconst [off2] ptr) mem)
@@ -56590,7 +56590,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUload256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUload256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQUload256 [off1] {sym} x:(ADDQconst [off2] ptr) mem)
@@ -56640,7 +56640,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUload512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUload512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDQUload512 [off1] {sym} x:(ADDQconst [off2] ptr) mem)
@@ -56690,7 +56690,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUstore128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUstore128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -56743,7 +56743,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUstore256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUstore256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -56796,7 +56796,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQUstore512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVDQUstore512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -56849,7 +56849,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVQ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VMOVQ x:(MOVQload [off] {sym} ptr mem))
@@ -56877,7 +56877,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVSDf2v(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVSDf2v(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VMOVSDf2v x:(MOVSDload [off] {sym} ptr mem))
@@ -56917,7 +56917,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVSSf2v(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMOVSSf2v(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VMOVSSf2v x:(MOVSSload [off] {sym} ptr mem))
@@ -56957,7 +56957,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -56987,7 +56987,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -57017,7 +57017,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -57047,7 +57047,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57079,7 +57079,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57111,7 +57111,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57143,7 +57143,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -57173,7 +57173,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -57203,7 +57203,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMULPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -57233,7 +57233,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57265,7 +57265,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57297,7 +57297,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VMULPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VMULPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57329,7 +57329,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSB128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSB128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57354,7 +57354,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSB256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSB256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57379,7 +57379,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSBMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSBMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -57406,7 +57406,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSBMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSBMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -57433,7 +57433,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57458,7 +57458,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57483,7 +57483,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57508,7 +57508,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -57535,7 +57535,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -57562,7 +57562,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -57589,7 +57589,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57614,7 +57614,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57639,7 +57639,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57664,7 +57664,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -57691,7 +57691,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -57718,7 +57718,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -57745,7 +57745,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSW128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57770,7 +57770,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPABSW256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -57795,7 +57795,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSWMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -57822,7 +57822,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPABSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPABSWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPABSWMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -57849,7 +57849,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKSSDW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -57876,7 +57876,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKSSDW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -57903,7 +57903,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKSSDW512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -57930,7 +57930,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57959,7 +57959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -57988,7 +57988,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKSSDWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKSSDWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58017,7 +58017,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKUSDW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58044,7 +58044,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKUSDW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58071,7 +58071,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPACKUSDW512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -58098,7 +58098,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58127,7 +58127,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58156,7 +58156,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPACKUSDWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPACKUSDWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58185,7 +58185,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58215,7 +58215,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58245,7 +58245,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58277,7 +58277,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58309,7 +58309,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58339,7 +58339,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58369,7 +58369,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -58399,7 +58399,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58431,7 +58431,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58463,7 +58463,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58495,7 +58495,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58525,7 +58525,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58555,7 +58555,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -58585,7 +58585,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58617,7 +58617,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58649,7 +58649,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58681,7 +58681,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58711,7 +58711,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58741,7 +58741,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58773,7 +58773,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58805,7 +58805,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58835,7 +58835,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58865,7 +58865,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58897,7 +58897,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -58929,7 +58929,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDUSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -58959,7 +58959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDUSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -58989,7 +58989,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59021,7 +59021,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59053,7 +59053,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDUSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -59083,7 +59083,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDUSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -59113,7 +59113,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59145,7 +59145,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDUSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDUSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59177,7 +59177,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -59207,7 +59207,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPADDW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -59237,7 +59237,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59269,7 +59269,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPADDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPADDWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59301,7 +59301,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPALIGNR128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPALIGNR128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPALIGNR128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -59329,7 +59329,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPALIGNR256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPALIGNR256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPALIGNR256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -59357,7 +59357,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPALIGNRMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPALIGNRMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59387,7 +59387,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPALIGNRMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPALIGNRMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -59417,7 +59417,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAND128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAND128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -59621,7 +59621,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAND256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAND256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -59825,7 +59825,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -60013,7 +60013,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60045,7 +60045,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60077,7 +60077,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60109,7 +60109,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDN128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDN128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPANDN128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -60136,7 +60136,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDN256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDN256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPANDN256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -60163,7 +60163,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDND512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDND512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPANDND512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -60190,7 +60190,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60219,7 +60219,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60248,7 +60248,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60277,7 +60277,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPANDNQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -60304,7 +60304,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60333,7 +60333,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60362,7 +60362,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDNQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDNQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60391,7 +60391,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPANDQ512 x (VPMOVMToVec64x8 k))
@@ -60481,7 +60481,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60513,7 +60513,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60545,7 +60545,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPANDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPANDQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60577,7 +60577,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPAVGB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -60607,7 +60607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPAVGB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -60637,7 +60637,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60669,7 +60669,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60701,7 +60701,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPAVGW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -60731,7 +60731,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPAVGW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -60761,7 +60761,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60793,7 +60793,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPAVGWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPAVGWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -60825,7 +60825,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDMBMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDMBMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -61039,7 +61039,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDMDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDMDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -61702,7 +61702,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDMQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDMQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -62426,7 +62426,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDMWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDMWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -62838,7 +62838,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDVB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDVB128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -66464,7 +66464,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBLENDVB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBLENDVB256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -69311,7 +69311,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTB128(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTB128 x:(VPINSRB128 [0] (Zero128 <t>) y))
@@ -69359,7 +69359,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTB256(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTB256 x:(VPINSRB128 [0] (Zero128 <t>) y))
@@ -69407,7 +69407,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTB512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTB512(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTB512 x:(VPINSRB128 [0] (Zero128 <t>) y))
@@ -69455,7 +69455,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTBMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTBMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69482,7 +69482,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTBMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTBMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69509,7 +69509,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTBMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTBMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTBMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69536,7 +69536,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69561,7 +69561,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69586,7 +69586,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTD512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69611,7 +69611,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69638,7 +69638,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69665,7 +69665,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTDMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69692,7 +69692,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69717,7 +69717,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69742,7 +69742,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPBROADCASTQ512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -69767,7 +69767,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69794,7 +69794,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69821,7 +69821,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPBROADCASTQMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -69848,7 +69848,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTW128(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTW128 x:(VPINSRW128 [0] (Zero128 <t>) y))
@@ -69896,7 +69896,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTW256(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTW256 x:(VPINSRW128 [0] (Zero128 <t>) y))
@@ -69944,7 +69944,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPBROADCASTW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPBROADCASTW512(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (VPBROADCASTW512 x:(VPINSRW128 [0] (Zero128 <t>) y))
@@ -69971,7 +69971,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCLMULQDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCLMULQDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCLMULQDQ128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -69999,7 +69999,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCLMULQDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCLMULQDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCLMULQDQ256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70027,7 +70027,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70057,7 +70057,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70087,7 +70087,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70115,7 +70115,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70145,7 +70145,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70175,7 +70175,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70205,7 +70205,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70235,7 +70235,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70265,7 +70265,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70295,7 +70295,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70325,7 +70325,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70355,7 +70355,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70385,7 +70385,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70415,7 +70415,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70445,7 +70445,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70475,7 +70475,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPEQW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPEQW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPEQW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70505,7 +70505,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70532,7 +70532,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70559,7 +70559,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70586,7 +70586,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70613,7 +70613,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70640,7 +70640,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70667,7 +70667,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70694,7 +70694,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70721,7 +70721,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -70748,7 +70748,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPGTW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPGTW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPGTW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -70775,7 +70775,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70803,7 +70803,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70833,7 +70833,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70863,7 +70863,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70893,7 +70893,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70923,7 +70923,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -70953,7 +70953,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPUD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -70981,7 +70981,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71011,7 +71011,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71041,7 +71041,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71071,7 +71071,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPCMPUQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -71099,7 +71099,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71129,7 +71129,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71159,7 +71159,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71189,7 +71189,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71219,7 +71219,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPUWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPUWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71249,7 +71249,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71279,7 +71279,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPCMPWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPCMPWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71309,7 +71309,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71338,7 +71338,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71367,7 +71367,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71396,7 +71396,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -71427,7 +71427,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -71458,7 +71458,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPDPWSSDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPDPWSSDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -71489,7 +71489,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERM2F128256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERM2F128256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERM2F128256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -71517,7 +71517,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERM2I128256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERM2I128256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERM2I128256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -71545,7 +71545,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -71572,7 +71572,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -71599,7 +71599,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71628,7 +71628,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71657,7 +71657,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -71684,7 +71684,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -71711,7 +71711,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71740,7 +71740,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71769,7 +71769,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2B128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2B128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71798,7 +71798,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2B256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2B256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71827,7 +71827,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2BMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2BMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -71858,7 +71858,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2BMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2BMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -71889,7 +71889,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2D128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2D128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71918,7 +71918,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2D256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2D256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71947,7 +71947,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2D512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2D512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -71976,7 +71976,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2DMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2DMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72007,7 +72007,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2DMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2DMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72038,7 +72038,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2DMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2DMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72069,7 +72069,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72098,7 +72098,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72127,7 +72127,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72156,7 +72156,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72187,7 +72187,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72218,7 +72218,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72249,7 +72249,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PS128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72278,7 +72278,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PS256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72307,7 +72307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PS512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72336,7 +72336,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PSMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72367,7 +72367,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PSMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72398,7 +72398,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2PSMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72429,7 +72429,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2Q128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2Q128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72458,7 +72458,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2Q256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2Q256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72487,7 +72487,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2Q512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2Q512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72516,7 +72516,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2QMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2QMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72547,7 +72547,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2QMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2QMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72578,7 +72578,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2QMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2QMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72609,7 +72609,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2W128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2W128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72638,7 +72638,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2W256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2W256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72667,7 +72667,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2WMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2WMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72698,7 +72698,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMI2WMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMI2WMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -72729,7 +72729,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -72756,7 +72756,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -72783,7 +72783,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72812,7 +72812,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72841,7 +72841,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -72868,7 +72868,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -72895,7 +72895,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72924,7 +72924,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72953,7 +72953,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -72980,7 +72980,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -73007,7 +73007,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -73036,7 +73036,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -73065,7 +73065,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73092,7 +73092,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPERMW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73119,7 +73119,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -73148,7 +73148,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPERMWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPERMWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -73177,7 +73177,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDBMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDBMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -73204,7 +73204,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDBMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDBMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -73231,7 +73231,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -73258,7 +73258,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -73285,7 +73285,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -73312,7 +73312,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -73339,7 +73339,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDWMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -73366,7 +73366,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPEXPANDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPEXPANDWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPEXPANDWMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -73393,7 +73393,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73420,7 +73420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73447,7 +73447,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73474,7 +73474,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73501,7 +73501,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73528,7 +73528,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHADDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHADDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHADDW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73555,7 +73555,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73582,7 +73582,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73609,7 +73609,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73636,7 +73636,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73663,7 +73663,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -73690,7 +73690,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPHSUBW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPHSUBW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPHSUBW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -73717,7 +73717,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPINSRD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPINSRD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPINSRD128 [0] (Zero128 <t>) y)
@@ -73754,7 +73754,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPINSRQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPINSRQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPINSRQ128 [0] (Zero128 <t>) y)
@@ -73791,7 +73791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -73816,7 +73816,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -73841,7 +73841,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -73866,7 +73866,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -73893,7 +73893,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -73920,7 +73920,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -73947,7 +73947,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -73972,7 +73972,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -73997,7 +73997,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPLZCNTQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -74022,7 +74022,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -74049,7 +74049,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -74076,7 +74076,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPLZCNTQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPLZCNTQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPLZCNTQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -74103,7 +74103,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDUBSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDUBSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMADDUBSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74130,7 +74130,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDUBSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDUBSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMADDUBSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74157,7 +74157,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDUBSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDUBSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74186,7 +74186,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDUBSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDUBSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74215,7 +74215,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDWD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDWD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMADDWD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74242,7 +74242,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDWD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDWD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMADDWD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74269,7 +74269,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDWDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDWDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74298,7 +74298,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMADDWDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMADDWDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74327,7 +74327,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74357,7 +74357,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74387,7 +74387,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74419,7 +74419,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74451,7 +74451,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74481,7 +74481,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74511,7 +74511,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -74541,7 +74541,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74573,7 +74573,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74605,7 +74605,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74637,7 +74637,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74667,7 +74667,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74697,7 +74697,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -74727,7 +74727,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74759,7 +74759,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74791,7 +74791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74823,7 +74823,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74853,7 +74853,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -74883,7 +74883,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74915,7 +74915,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -74947,7 +74947,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -74977,7 +74977,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75007,7 +75007,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75039,7 +75039,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75071,7 +75071,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75101,7 +75101,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75131,7 +75131,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -75161,7 +75161,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75193,7 +75193,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75225,7 +75225,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75257,7 +75257,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75287,7 +75287,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75317,7 +75317,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -75347,7 +75347,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75379,7 +75379,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75411,7 +75411,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75443,7 +75443,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75473,7 +75473,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMAXUW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75503,7 +75503,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75535,7 +75535,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMAXUWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMAXUWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75567,7 +75567,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75597,7 +75597,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75627,7 +75627,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75659,7 +75659,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75691,7 +75691,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75721,7 +75721,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75751,7 +75751,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -75781,7 +75781,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75813,7 +75813,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75845,7 +75845,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75877,7 +75877,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -75907,7 +75907,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -75937,7 +75937,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -75967,7 +75967,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -75999,7 +75999,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76031,7 +76031,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76063,7 +76063,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -76093,7 +76093,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -76123,7 +76123,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76155,7 +76155,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76187,7 +76187,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -76217,7 +76217,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -76247,7 +76247,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76279,7 +76279,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76311,7 +76311,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -76341,7 +76341,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -76371,7 +76371,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -76401,7 +76401,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76433,7 +76433,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76465,7 +76465,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76497,7 +76497,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -76527,7 +76527,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -76557,7 +76557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -76587,7 +76587,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76619,7 +76619,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76651,7 +76651,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76683,7 +76683,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -76713,7 +76713,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMINUW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -76743,7 +76743,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76775,7 +76775,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMINUWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMINUWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -76807,7 +76807,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -76832,7 +76832,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -76857,7 +76857,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBD512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -76882,7 +76882,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -76909,7 +76909,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -76936,7 +76936,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBDMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -76963,7 +76963,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -76988,7 +76988,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77013,7 +77013,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBQ512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77038,7 +77038,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77065,7 +77065,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBQMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77092,7 +77092,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBW128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77117,7 +77117,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBW256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77142,7 +77142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBW512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXBW512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77167,7 +77167,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBWMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77194,7 +77194,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBWMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77221,7 +77221,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXBWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXBWMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXBWMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -77248,7 +77248,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXDQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77273,7 +77273,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXDQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77298,7 +77298,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXDQ512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77323,7 +77323,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXDQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77350,7 +77350,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXDQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77377,7 +77377,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXDQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXDQMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -77404,7 +77404,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77429,7 +77429,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77454,7 +77454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWD512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77479,7 +77479,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77506,7 +77506,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77533,7 +77533,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWDMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -77560,7 +77560,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77585,7 +77585,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77610,7 +77610,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVSXWQ512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77635,7 +77635,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77662,7 +77662,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77689,7 +77689,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVSXWQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVSXWQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVSXWQMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77716,7 +77716,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec16x16ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec16x16ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec16x16ToM (VPMOVMToVec16x16 x))
// result: x
@@ -77730,7 +77730,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec16x32ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec16x32ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec16x32ToM (VPMOVMToVec16x32 x))
// result: x
@@ -77744,7 +77744,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec16x8ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec16x8ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec16x8ToM (VPMOVMToVec16x8 x))
// result: x
@@ -77758,7 +77758,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec32x16ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec32x16ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec32x16ToM (VPMOVMToVec32x16 x))
// result: x
@@ -77772,7 +77772,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec32x4ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec32x4ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec32x4ToM (VPMOVMToVec32x4 x))
// result: x
@@ -77786,7 +77786,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec32x8ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec32x8ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec32x8ToM (VPMOVMToVec32x8 x))
// result: x
@@ -77800,7 +77800,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec64x2ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec64x2ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec64x2ToM (VPMOVMToVec64x2 x))
// result: x
@@ -77814,7 +77814,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec64x4ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec64x4ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec64x4ToM (VPMOVMToVec64x4 x))
// result: x
@@ -77828,7 +77828,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec64x8ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec64x8ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec64x8ToM (VPMOVMToVec64x8 x))
// result: x
@@ -77842,7 +77842,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec8x16ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec8x16ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec8x16ToM (VPMOVMToVec8x16 x))
// result: x
@@ -77856,7 +77856,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec8x32ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec8x32ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec8x32ToM (VPMOVMToVec8x32 x))
// result: x
@@ -77870,7 +77870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVVec8x64ToM(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVVec8x64ToM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVVec8x64ToM (VPMOVMToVec8x64 x))
// result: x
@@ -77884,7 +77884,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77909,7 +77909,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77934,7 +77934,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBD512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -77959,7 +77959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -77986,7 +77986,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78013,7 +78013,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBDMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78040,7 +78040,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78065,7 +78065,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78090,7 +78090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBQ512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78115,7 +78115,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78142,7 +78142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBQMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78169,7 +78169,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBW128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78194,7 +78194,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBW256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78219,7 +78219,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBW512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXBW512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78244,7 +78244,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBWMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78271,7 +78271,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBWMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78298,7 +78298,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXBWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXBWMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXBWMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -78325,7 +78325,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXDQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78350,7 +78350,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXDQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78375,7 +78375,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXDQ512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78400,7 +78400,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXDQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78427,7 +78427,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXDQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78454,7 +78454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXDQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXDQMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -78481,7 +78481,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78506,7 +78506,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWD256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78531,7 +78531,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWD512 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78556,7 +78556,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78583,7 +78583,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWDMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78610,7 +78610,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWDMasked512 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -78637,7 +78637,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78662,7 +78662,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWQ256 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78687,7 +78687,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPMOVZXWQ512 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -78712,7 +78712,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78739,7 +78739,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWQMasked256 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78766,7 +78766,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMOVZXWQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMOVZXWQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMOVZXWQMasked512 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -78793,7 +78793,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -78823,7 +78823,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -78853,7 +78853,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHUW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHUW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULHUW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -78883,7 +78883,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHUW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHUW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULHUW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -78913,7 +78913,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHUWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHUWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -78945,7 +78945,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHUWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHUWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -78977,7 +78977,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULHW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -79007,7 +79007,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULHW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -79037,7 +79037,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79069,7 +79069,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULHWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULHWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79101,7 +79101,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLD128 x (VPBROADCASTD128 (VMOVD (MOVLconst [c]))))
@@ -79159,7 +79159,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLD256 x (VPBROADCASTD256 (VMOVD (MOVLconst [c]))))
@@ -79217,7 +79217,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLD512 x (VPBROADCASTD512 (VMOVD (MOVLconst [c]))))
@@ -79275,7 +79275,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79307,7 +79307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79339,7 +79339,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79371,7 +79371,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLQ128 x (VPBROADCASTQ128 (VMOVQ (MOVQconst [c]))))
@@ -79429,7 +79429,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLQ256 x (VPBROADCASTQ256 (VMOVQ (MOVQconst [c]))))
@@ -79487,7 +79487,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLQ512 x (VPBROADCASTQ512 (VMOVQ (MOVQconst [c]))))
@@ -79545,7 +79545,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79577,7 +79577,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79609,7 +79609,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79641,7 +79641,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLW128 x (VPBROADCASTW128 (VMOVQ (MOVLconst [c]))))
@@ -79699,7 +79699,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLW256 x (VPBROADCASTW256 (VMOVQ (MOVLconst [c]))))
@@ -79757,7 +79757,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULLW512 x (VPBROADCASTW512 (VMOVQ (MOVLconst [c]))))
@@ -79790,7 +79790,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79822,7 +79822,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULLWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULLWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -79854,7 +79854,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULUDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULUDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULUDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -79884,7 +79884,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPMULUDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPMULUDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULUDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -79914,7 +79914,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTB128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTB128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -79939,7 +79939,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTB256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTB256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -79964,7 +79964,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTBMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTBMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -79991,7 +79991,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTBMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTBMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -80018,7 +80018,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80043,7 +80043,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80068,7 +80068,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80093,7 +80093,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -80120,7 +80120,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -80147,7 +80147,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -80174,7 +80174,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTQ128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80199,7 +80199,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTQ256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80224,7 +80224,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTQ512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80249,7 +80249,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTQMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -80276,7 +80276,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTQMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -80303,7 +80303,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTQMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -80330,7 +80330,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTW128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80355,7 +80355,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPOPCNTW256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -80380,7 +80380,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTWMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -80407,7 +80407,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOPCNTWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOPCNTWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPOPCNTWMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -80434,7 +80434,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOR128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOR128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -80606,7 +80606,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPOR256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPOR256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -80778,7 +80778,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -80970,7 +80970,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81002,7 +81002,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81034,7 +81034,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81066,7 +81066,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPORQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -81096,7 +81096,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81128,7 +81128,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81160,7 +81160,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPORQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPORQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81192,7 +81192,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81218,7 +81218,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81244,7 +81244,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81270,7 +81270,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -81298,7 +81298,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -81326,7 +81326,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -81354,7 +81354,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLQ128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81380,7 +81380,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLQ256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81406,7 +81406,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPROLQ512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81432,7 +81432,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLQMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -81460,7 +81460,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLQMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -81488,7 +81488,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLQMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -81516,7 +81516,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -81543,7 +81543,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -81570,7 +81570,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -81597,7 +81597,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81626,7 +81626,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81655,7 +81655,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81684,7 +81684,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -81711,7 +81711,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -81738,7 +81738,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPROLVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -81765,7 +81765,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81794,7 +81794,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81823,7 +81823,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPROLVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPROLVQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -81852,7 +81852,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81878,7 +81878,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81904,7 +81904,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -81930,7 +81930,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -81958,7 +81958,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -81986,7 +81986,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -82014,7 +82014,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQ128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORQ128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -82040,7 +82040,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQ256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORQ256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -82066,7 +82066,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQ512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPRORQ512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -82092,7 +82092,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORQMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -82120,7 +82120,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORQMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -82148,7 +82148,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORQMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORQMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -82176,7 +82176,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -82203,7 +82203,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -82230,7 +82230,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -82257,7 +82257,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82286,7 +82286,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82315,7 +82315,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82344,7 +82344,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -82371,7 +82371,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -82398,7 +82398,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPRORVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -82425,7 +82425,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82454,7 +82454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82483,7 +82483,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPRORVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPRORVQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82512,7 +82512,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSADBW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSADBW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSADBW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -82539,7 +82539,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSADBW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSADBW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSADBW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -82566,7 +82566,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -82594,7 +82594,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -82622,7 +82622,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -82650,7 +82650,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82680,7 +82680,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82710,7 +82710,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82740,7 +82740,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDQ128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -82768,7 +82768,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDQ256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -82796,7 +82796,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -82824,7 +82824,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82854,7 +82854,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82884,7 +82884,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82914,7 +82914,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82943,7 +82943,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -82972,7 +82972,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83001,7 +83001,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83032,7 +83032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83063,7 +83063,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83094,7 +83094,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQ128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83123,7 +83123,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQ256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83152,7 +83152,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQ512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83181,7 +83181,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83212,7 +83212,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83243,7 +83243,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVQMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83274,7 +83274,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVW128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83303,7 +83303,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVW256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83332,7 +83332,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVWMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83363,7 +83363,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDVWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDVWMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83394,7 +83394,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDW128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -83422,7 +83422,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHLDW256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -83450,7 +83450,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83480,7 +83480,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHLDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHLDWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83510,7 +83510,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -83538,7 +83538,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -83566,7 +83566,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -83594,7 +83594,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83624,7 +83624,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83654,7 +83654,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83684,7 +83684,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDQ128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -83712,7 +83712,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDQ256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -83740,7 +83740,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -83768,7 +83768,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83798,7 +83798,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83828,7 +83828,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83858,7 +83858,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83887,7 +83887,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83916,7 +83916,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -83945,7 +83945,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVDMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -83976,7 +83976,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVDMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84007,7 +84007,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVDMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84038,7 +84038,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQ128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84067,7 +84067,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQ256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84096,7 +84096,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQ512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84125,7 +84125,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84156,7 +84156,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84187,7 +84187,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVQMasked512(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84218,7 +84218,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVW128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84247,7 +84247,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVW256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84276,7 +84276,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVWMasked128(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84307,7 +84307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDVWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDVWMasked256(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -84338,7 +84338,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDW128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -84366,7 +84366,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHRDW256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -84394,7 +84394,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84424,7 +84424,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHRDWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHRDWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84454,7 +84454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -84481,7 +84481,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -84508,7 +84508,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84537,7 +84537,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -84566,7 +84566,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84592,7 +84592,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84618,7 +84618,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84644,7 +84644,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -84672,7 +84672,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -84700,7 +84700,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -84728,7 +84728,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFHW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFHW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFHW128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84754,7 +84754,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFHW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFHW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFHW256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84780,7 +84780,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFHWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFHWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFHWMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -84808,7 +84808,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFHWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFHWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFHWMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -84836,7 +84836,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFLW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFLW128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFLW128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84862,7 +84862,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFLW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFLW256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSHUFLW256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -84888,7 +84888,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFLWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFLWMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFLWMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -84916,7 +84916,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSHUFLWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSHUFLWMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSHUFLWMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -84944,7 +84944,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGNB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGNB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGNB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -84971,7 +84971,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGNB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGNB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGNB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -84998,7 +84998,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGND128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGND128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGND128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -85025,7 +85025,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGND256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGND256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGND256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -85052,7 +85052,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGNW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGNW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGNW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -85079,7 +85079,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSIGNW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSIGNW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSIGNW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -85106,7 +85106,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLD128 x (MOVQconst [c]))
@@ -85124,7 +85124,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLD128const [a] x)
// cond: a==0
@@ -85140,7 +85140,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLD256 x (MOVQconst [c]))
@@ -85158,7 +85158,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLD256const [a] x)
// cond: a==0
@@ -85174,7 +85174,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLD512 x (MOVQconst [c]))
@@ -85192,7 +85192,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLD512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLD512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLD512const [a] x)
// cond: a==0
@@ -85230,7 +85230,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85250,7 +85250,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLDMasked128const [a] x mask)
@@ -85290,7 +85290,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85310,7 +85310,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLDMasked256const [a] x mask)
@@ -85350,7 +85350,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85370,7 +85370,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLDMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLDMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLDMasked512const [a] x mask)
@@ -85410,7 +85410,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQ128 x (MOVQconst [c]))
@@ -85428,7 +85428,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLQ128const [a] x)
// cond: a==0
@@ -85444,7 +85444,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQ256 x (MOVQconst [c]))
@@ -85462,7 +85462,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLQ256const [a] x)
// cond: a==0
@@ -85478,7 +85478,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQ512 x (MOVQconst [c]))
@@ -85496,7 +85496,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQ512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQ512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLQ512const [a] x)
// cond: a==0
@@ -85534,7 +85534,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85554,7 +85554,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQMasked128const [a] x mask)
@@ -85594,7 +85594,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85614,7 +85614,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQMasked256const [a] x mask)
@@ -85654,7 +85654,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85674,7 +85674,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLQMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLQMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLQMasked512const [a] x mask)
@@ -85714,7 +85714,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -85741,7 +85741,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -85768,7 +85768,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -85795,7 +85795,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85824,7 +85824,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85853,7 +85853,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85882,7 +85882,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -85909,7 +85909,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -85936,7 +85936,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -85963,7 +85963,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -85992,7 +85992,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86021,7 +86021,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86050,7 +86050,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -86077,7 +86077,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLVW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -86104,7 +86104,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86133,7 +86133,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLVWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLVWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86162,7 +86162,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLW128 x (MOVQconst [c]))
@@ -86180,7 +86180,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLW128const [a] x)
// cond: a==0
@@ -86196,7 +86196,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLW256 x (MOVQconst [c]))
@@ -86214,7 +86214,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLW256const [a] x)
// cond: a==0
@@ -86230,7 +86230,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLW512 x (MOVQconst [c]))
@@ -86248,7 +86248,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLW512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLW512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLW512const [a] x)
// cond: a==0
@@ -86264,7 +86264,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86284,7 +86284,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLWMasked128const [a] x mask)
@@ -86324,7 +86324,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86344,7 +86344,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSLLWMasked256const [a] x mask)
@@ -86384,7 +86384,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86404,7 +86404,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSLLWMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSLLWMasked512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSLLWMasked512const [a] x mask)
// cond: a==0
@@ -86420,7 +86420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAD128 x (MOVQconst [c]))
@@ -86438,7 +86438,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAD128const [a] x)
// cond: a==0
@@ -86454,7 +86454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAD256 x (MOVQconst [c]))
@@ -86472,7 +86472,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAD256const [a] x)
// cond: a==0
@@ -86488,7 +86488,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAD512 x (MOVQconst [c]))
@@ -86506,7 +86506,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAD512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAD512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAD512const [a] x)
// cond: a==0
@@ -86544,7 +86544,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86564,7 +86564,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRADMasked128const [a] x mask)
@@ -86604,7 +86604,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86624,7 +86624,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRADMasked256const [a] x mask)
@@ -86664,7 +86664,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86684,7 +86684,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRADMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRADMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRADMasked512const [a] x mask)
@@ -86724,7 +86724,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQ128 x (MOVQconst [c]))
@@ -86742,7 +86742,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAQ128const [a] x)
// cond: a==0
@@ -86780,7 +86780,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQ256 x (MOVQconst [c]))
@@ -86798,7 +86798,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAQ256const [a] x)
// cond: a==0
@@ -86836,7 +86836,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQ512 x (MOVQconst [c]))
@@ -86854,7 +86854,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQ512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQ512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAQ512const [a] x)
// cond: a==0
@@ -86892,7 +86892,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86912,7 +86912,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQMasked128const [a] x mask)
@@ -86952,7 +86952,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -86972,7 +86972,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQMasked256const [a] x mask)
@@ -87012,7 +87012,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87032,7 +87032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAQMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAQMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAQMasked512const [a] x mask)
@@ -87072,7 +87072,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -87099,7 +87099,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -87126,7 +87126,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -87153,7 +87153,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87182,7 +87182,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87211,7 +87211,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87240,7 +87240,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -87267,7 +87267,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -87294,7 +87294,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -87321,7 +87321,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87350,7 +87350,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87379,7 +87379,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87408,7 +87408,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -87435,7 +87435,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAVW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -87462,7 +87462,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87491,7 +87491,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAVWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAVWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87520,7 +87520,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAW128 x (MOVQconst [c]))
@@ -87538,7 +87538,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAW128const [a] x)
// cond: a==0
@@ -87554,7 +87554,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAW256 x (MOVQconst [c]))
@@ -87572,7 +87572,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAW256const [a] x)
// cond: a==0
@@ -87588,7 +87588,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAW512 x (MOVQconst [c]))
@@ -87606,7 +87606,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAW512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAW512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAW512const [a] x)
// cond: a==0
@@ -87622,7 +87622,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87642,7 +87642,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAWMasked128const [a] x mask)
@@ -87682,7 +87682,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87702,7 +87702,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRAWMasked256const [a] x mask)
@@ -87742,7 +87742,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87762,7 +87762,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRAWMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRAWMasked512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRAWMasked512const [a] x mask)
// cond: a==0
@@ -87778,7 +87778,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLD128 x (MOVQconst [c]))
@@ -87796,7 +87796,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLD128const [a] x)
// cond: a==0
@@ -87812,7 +87812,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLD256 x (MOVQconst [c]))
@@ -87830,7 +87830,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLD256const [a] x)
// cond: a==0
@@ -87846,7 +87846,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLD512 x (MOVQconst [c]))
@@ -87864,7 +87864,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLD512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLD512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLD512const [a] x)
// cond: a==0
@@ -87902,7 +87902,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87922,7 +87922,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLDMasked128const [a] x mask)
@@ -87962,7 +87962,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -87982,7 +87982,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLDMasked256const [a] x mask)
@@ -88022,7 +88022,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88042,7 +88042,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLDMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLDMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLDMasked512const [a] x mask)
@@ -88082,7 +88082,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQ128 x (MOVQconst [c]))
@@ -88100,7 +88100,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLQ128const [a] x)
// cond: a==0
@@ -88116,7 +88116,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQ256 x (MOVQconst [c]))
@@ -88134,7 +88134,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLQ256const [a] x)
// cond: a==0
@@ -88150,7 +88150,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQ512 x (MOVQconst [c]))
@@ -88168,7 +88168,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQ512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQ512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLQ512const [a] x)
// cond: a==0
@@ -88206,7 +88206,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88226,7 +88226,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQMasked128const [a] x mask)
@@ -88266,7 +88266,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88286,7 +88286,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQMasked256const [a] x mask)
@@ -88326,7 +88326,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88346,7 +88346,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLQMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLQMasked512const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLQMasked512const [a] x mask)
@@ -88386,7 +88386,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -88413,7 +88413,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -88440,7 +88440,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -88467,7 +88467,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88496,7 +88496,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88525,7 +88525,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88554,7 +88554,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -88581,7 +88581,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -88608,7 +88608,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -88635,7 +88635,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88664,7 +88664,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88693,7 +88693,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88722,7 +88722,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -88749,7 +88749,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLVW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -88776,7 +88776,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88805,7 +88805,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLVWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLVWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88834,7 +88834,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLW128 x (MOVQconst [c]))
@@ -88852,7 +88852,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW128const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLW128const [a] x)
// cond: a==0
@@ -88868,7 +88868,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLW256 x (MOVQconst [c]))
@@ -88886,7 +88886,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW256const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLW256const [a] x)
// cond: a==0
@@ -88902,7 +88902,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLW512 x (MOVQconst [c]))
@@ -88920,7 +88920,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLW512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLW512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLW512const [a] x)
// cond: a==0
@@ -88936,7 +88936,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -88956,7 +88956,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked128const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked128const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLWMasked128const [a] x mask)
@@ -88996,7 +88996,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89016,7 +89016,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked256const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked256const(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSRLWMasked256const [a] x mask)
@@ -89056,7 +89056,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89076,7 +89076,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSRLWMasked512const(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSRLWMasked512const(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VPSRLWMasked512const [a] x mask)
// cond: a==0
@@ -89092,7 +89092,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89119,7 +89119,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89146,7 +89146,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89175,7 +89175,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89204,7 +89204,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89231,7 +89231,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89258,7 +89258,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -89285,7 +89285,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89314,7 +89314,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89343,7 +89343,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89372,7 +89372,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89399,7 +89399,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89426,7 +89426,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -89453,7 +89453,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89482,7 +89482,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89511,7 +89511,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89540,7 +89540,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89567,7 +89567,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89594,7 +89594,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89623,7 +89623,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89652,7 +89652,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89679,7 +89679,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89706,7 +89706,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89735,7 +89735,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89764,7 +89764,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSB128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSB128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBUSB128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89791,7 +89791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSB256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSB256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBUSB256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89818,7 +89818,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSBMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSBMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89847,7 +89847,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSBMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSBMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89876,7 +89876,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBUSW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -89903,7 +89903,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBUSW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -89930,7 +89930,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89959,7 +89959,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBUSWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBUSWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -89988,7 +89988,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBW128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBW128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBW128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90015,7 +90015,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBW256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBW256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPSUBW256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90042,7 +90042,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBWMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBWMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90071,7 +90071,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPSUBWMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPSUBWMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90100,7 +90100,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGD128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90130,7 +90130,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGD256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90160,7 +90160,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGD512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90190,7 +90190,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGQ128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90220,7 +90220,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGQ256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90250,7 +90250,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPTERNLOGQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPTERNLOGQ512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -90280,7 +90280,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90307,7 +90307,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90334,7 +90334,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -90361,7 +90361,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHQDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHQDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHQDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90388,7 +90388,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHQDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHQDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHQDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90415,7 +90415,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHQDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHQDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHQDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -90442,7 +90442,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHWD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHWD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHWD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90469,7 +90469,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKHWD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKHWD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKHWD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90496,7 +90496,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90523,7 +90523,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90550,7 +90550,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -90577,7 +90577,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLQDQ128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLQDQ128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLQDQ128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90604,7 +90604,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLQDQ256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLQDQ256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLQDQ256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90631,7 +90631,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLQDQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLQDQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLQDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -90658,7 +90658,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLWD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLWD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLWD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -90685,7 +90685,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPUNPCKLWD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPUNPCKLWD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPUNPCKLWD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -90712,7 +90712,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXOR128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXOR128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -90840,7 +90840,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXOR256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXOR256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -90968,7 +90968,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -91096,7 +91096,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91128,7 +91128,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91160,7 +91160,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91192,7 +91192,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORQ512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORQ512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPXORQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -91222,7 +91222,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORQMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORQMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91254,7 +91254,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORQMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORQMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91286,7 +91286,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VPXORQMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VPXORQMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -91318,7 +91318,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCP14PD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91343,7 +91343,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCP14PD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91368,7 +91368,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCP14PD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91393,7 +91393,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -91420,7 +91420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -91447,7 +91447,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -91474,7 +91474,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCP14PS512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91499,7 +91499,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -91526,7 +91526,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -91553,7 +91553,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCP14PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCP14PSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRCP14PSMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -91580,7 +91580,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCPPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCPPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCPPS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91605,7 +91605,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRCPPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRCPPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRCPPS256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91630,7 +91630,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91656,7 +91656,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91682,7 +91682,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91708,7 +91708,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -91736,7 +91736,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -91764,7 +91764,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -91792,7 +91792,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPS128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91818,7 +91818,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPS256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91844,7 +91844,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VREDUCEPS512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91870,7 +91870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPSMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -91898,7 +91898,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPSMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -91926,7 +91926,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VREDUCEPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VREDUCEPSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VREDUCEPSMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -91954,7 +91954,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -91980,7 +91980,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92006,7 +92006,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92032,7 +92032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -92060,7 +92060,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -92088,7 +92088,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -92116,7 +92116,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPS128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92142,7 +92142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPS256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92168,7 +92168,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRNDSCALEPS512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92194,7 +92194,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPSMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -92222,7 +92222,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPSMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -92250,7 +92250,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRNDSCALEPSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRNDSCALEPSMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -92278,7 +92278,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VROUNDPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VROUNDPD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VROUNDPD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92304,7 +92304,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VROUNDPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VROUNDPD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VROUNDPD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92330,7 +92330,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VROUNDPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VROUNDPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VROUNDPS128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92356,7 +92356,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VROUNDPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VROUNDPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VROUNDPS256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92382,7 +92382,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRT14PD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92407,7 +92407,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRT14PD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92432,7 +92432,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRT14PD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92457,7 +92457,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -92484,7 +92484,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -92511,7 +92511,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -92538,7 +92538,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRT14PS512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92563,7 +92563,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -92590,7 +92590,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -92617,7 +92617,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRT14PSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRT14PSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VRSQRT14PSMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -92644,7 +92644,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRTPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRTPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRTPS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92669,7 +92669,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VRSQRTPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VRSQRTPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VRSQRTPS256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -92694,7 +92694,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -92721,7 +92721,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -92748,7 +92748,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -92775,7 +92775,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -92804,7 +92804,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -92833,7 +92833,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -92862,7 +92862,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -92889,7 +92889,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -92916,7 +92916,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSCALEFPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -92943,7 +92943,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -92972,7 +92972,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93001,7 +93001,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSCALEFPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSCALEFPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93030,7 +93030,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -93058,7 +93058,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -93086,7 +93086,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -93114,7 +93114,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPS128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -93142,7 +93142,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPS256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -93170,7 +93170,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSHUFPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSHUFPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSHUFPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -93198,7 +93198,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPD128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPD128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93223,7 +93223,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPD256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPD256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93248,7 +93248,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPD512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPD512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93273,7 +93273,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPDMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -93300,7 +93300,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPDMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -93327,7 +93327,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPDMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -93354,7 +93354,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPS128(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPS128 l:(VMOVDQUload128 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93379,7 +93379,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPS256(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPS256 l:(VMOVDQUload256 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93404,7 +93404,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPS512(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQRTPS512 l:(VMOVDQUload512 {sym} [off] ptr mem))
// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)
@@ -93429,7 +93429,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPSMasked128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPSMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
@@ -93456,7 +93456,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPSMasked256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPSMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
@@ -93483,7 +93483,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSQRTPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSQRTPSMasked512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSQRTPSMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
@@ -93510,7 +93510,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPD128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPD128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPD128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -93537,7 +93537,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPD256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPD256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPD256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -93564,7 +93564,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPD512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPD512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPD512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -93591,7 +93591,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPDMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPDMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93620,7 +93620,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPDMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPDMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93649,7 +93649,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPDMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPDMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93678,7 +93678,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPS128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPS128(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPS128 x l:(VMOVDQUload128 {sym} [off] ptr mem))
@@ -93705,7 +93705,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPS256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPS256(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPS256 x l:(VMOVDQUload256 {sym} [off] ptr mem))
@@ -93732,7 +93732,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPS512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPS512(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSUBPS512 x l:(VMOVDQUload512 {sym} [off] ptr mem))
@@ -93759,7 +93759,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPSMasked128(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPSMasked128(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93788,7 +93788,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPSMasked256(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPSMasked256(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93817,7 +93817,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64VSUBPSMasked512(v *ssa.Value) bool {
+func rewriteValue_OpAMD64VSUBPSMasked512(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93846,7 +93846,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDLlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XADDLlock(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93874,7 +93874,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDQlock(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XADDQlock(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93902,7 +93902,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XCHGL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -93953,7 +93953,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XCHGQ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94004,7 +94004,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORBconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORBconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORBconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -94052,7 +94052,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORL (SHLL (MOVLconst [1]) y) x)
@@ -94143,7 +94143,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORLconst [1] (SETNE x))
// result: (SETEQ x)
@@ -94293,7 +94293,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORLconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -94341,7 +94341,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94414,7 +94414,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORLmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94465,7 +94465,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORQ (SHLQ (MOVQconst [1]) y) x)
@@ -94580,7 +94580,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconst(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORQconst [c] (XORQconst [d] x))
// result: (XORQconst [c ^ d] x)
@@ -94620,7 +94620,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORQconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -94668,7 +94668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94741,7 +94741,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORQmodify(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94792,7 +94792,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORWconstmodify(v *ssa.Value) bool {
+func rewriteValue_OpAMD64XORWconstmodify(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORWconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -94840,7 +94840,7 @@
}
return false
}
-func rewriteValueAMD64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (LEAQ {sym} base)
@@ -94853,7 +94853,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAdd32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94872,7 +94872,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAdd64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94891,7 +94891,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94906,7 +94906,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd32value(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd32value(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94921,7 +94921,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd64value(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd64value(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94936,7 +94936,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -94951,7 +94951,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -94968,7 +94968,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -94985,7 +94985,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicExchange32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95000,7 +95000,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicExchange64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95015,7 +95015,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicExchange8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95030,7 +95030,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -95043,7 +95043,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -95056,7 +95056,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -95069,7 +95069,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoadPtr(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -95082,7 +95082,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicOr32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95097,7 +95097,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicOr32value(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr32value(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95112,7 +95112,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicOr64value(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr64value(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95127,7 +95127,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95142,7 +95142,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95161,7 +95161,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95180,7 +95180,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95199,7 +95199,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStorePtrNoWB(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -95218,7 +95218,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -95261,7 +95261,7 @@
}
return false
}
-func rewriteValueAMD64_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -95304,7 +95304,7 @@
}
return false
}
-func rewriteValueAMD64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -95352,7 +95352,7 @@
}
return false
}
-func rewriteValueAMD64_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -95395,7 +95395,7 @@
}
return false
}
-func rewriteValueAMD64_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Bswap16 x)
// result: (ROLWconst [8] x)
@@ -95407,7 +95407,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeil(v *ssa.Value) bool {
+func rewriteValue_OpCeil(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (ROUNDSD [2] x)
@@ -95419,7 +95419,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilFloat32x4 x)
// result: (VROUNDPS128 [2] x)
@@ -95431,7 +95431,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpCeilFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilFloat32x8 x)
// result: (VROUNDPS256 [2] x)
@@ -95443,7 +95443,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpCeilFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilFloat64x2 x)
// result: (VROUNDPD128 [2] x)
@@ -95455,7 +95455,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilFloat64x4 x)
// result: (VROUNDPD256 [2] x)
@@ -95467,7 +95467,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat32x16 [a] x)
// result: (VRNDSCALEPS512 [a+2] x)
@@ -95480,7 +95480,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat32x4 [a] x)
// result: (VRNDSCALEPS128 [a+2] x)
@@ -95493,7 +95493,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat32x8 [a] x)
// result: (VRNDSCALEPS256 [a+2] x)
@@ -95506,7 +95506,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat64x2 [a] x)
// result: (VRNDSCALEPD128 [a+2] x)
@@ -95519,7 +95519,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat64x4 [a] x)
// result: (VRNDSCALEPD256 [a+2] x)
@@ -95532,7 +95532,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledFloat64x8 [a] x)
// result: (VRNDSCALEPD512 [a+2] x)
@@ -95545,7 +95545,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat32x16 [a] x)
// result: (VREDUCEPS512 [a+2] x)
@@ -95558,7 +95558,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat32x4 [a] x)
// result: (VREDUCEPS128 [a+2] x)
@@ -95571,7 +95571,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat32x8 [a] x)
// result: (VREDUCEPS256 [a+2] x)
@@ -95584,7 +95584,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat64x2 [a] x)
// result: (VREDUCEPD128 [a+2] x)
@@ -95597,7 +95597,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat64x4 [a] x)
// result: (VREDUCEPD256 [a+2] x)
@@ -95610,7 +95610,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeilScaledResidueFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpCeilScaledResidueFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CeilScaledResidueFloat64x8 [a] x)
// result: (VREDUCEPD512 [a+2] x)
@@ -95623,7 +95623,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95639,7 +95639,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95655,7 +95655,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95671,7 +95671,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95687,7 +95687,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95703,7 +95703,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95719,7 +95719,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95735,7 +95735,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95751,7 +95751,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95767,7 +95767,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95783,7 +95783,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95799,7 +95799,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95815,7 +95815,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95831,7 +95831,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95847,7 +95847,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95863,7 +95863,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95879,7 +95879,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95895,7 +95895,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpCompressInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95911,7 +95911,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95927,7 +95927,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95943,7 +95943,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95959,7 +95959,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95975,7 +95975,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95991,7 +95991,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96007,7 +96007,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96023,7 +96023,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96039,7 +96039,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96055,7 +96055,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96071,7 +96071,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96087,7 +96087,7 @@
return true
}
}
-func rewriteValueAMD64_OpCompressUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpCompressUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -96103,7 +96103,7 @@
return true
}
}
-func rewriteValueAMD64_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -97082,7 +97082,7 @@
}
return false
}
-func rewriteValueAMD64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [c])
// result: (MOVLconst [int32(c)])
for {
@@ -97092,7 +97092,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [c])
// result: (MOVLconst [int32(c)])
for {
@@ -97102,7 +97102,7 @@
return true
}
}
-func rewriteValueAMD64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [c])
// result: (MOVLconst [ssa.B2i32(c)])
for {
@@ -97112,7 +97112,7 @@
return true
}
}
-func rewriteValueAMD64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil )
// result: (MOVQconst [0])
for {
@@ -97121,7 +97121,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97137,7 +97137,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz16NonZero(v *ssa.Value) bool {
+func rewriteValue_OpCtz16NonZero(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ctz16NonZero x)
// cond: buildcfg.GOAMD64 >= 3
@@ -97165,7 +97165,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97200,7 +97200,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz32NonZero(v *ssa.Value) bool {
+func rewriteValue_OpCtz32NonZero(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// cond: buildcfg.GOAMD64 >= 3
@@ -97228,7 +97228,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97267,7 +97267,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz64NonZero(v *ssa.Value) bool {
+func rewriteValue_OpCtz64NonZero(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97299,7 +97299,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97315,7 +97315,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz8NonZero(v *ssa.Value) bool {
+func rewriteValue_OpCtz8NonZero(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ctz8NonZero x)
// cond: buildcfg.GOAMD64 >= 3
@@ -97343,7 +97343,7 @@
}
return false
}
-func rewriteValueAMD64_OpCvt16toMask16x16(v *ssa.Value) bool {
+func rewriteValue_OpCvt16toMask16x16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt16toMask16x16 <t> x)
@@ -97359,7 +97359,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt16toMask32x16(v *ssa.Value) bool {
+func rewriteValue_OpCvt16toMask32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt16toMask32x16 <t> x)
@@ -97375,7 +97375,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt16toMask8x16(v *ssa.Value) bool {
+func rewriteValue_OpCvt16toMask8x16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt16toMask8x16 <t> x)
@@ -97391,7 +97391,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97436,7 +97436,7 @@
}
return false
}
-func rewriteValueAMD64_OpCvt32Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97483,7 +97483,7 @@
}
return false
}
-func rewriteValueAMD64_OpCvt32toMask16x32(v *ssa.Value) bool {
+func rewriteValue_OpCvt32toMask16x32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt32toMask16x32 <t> x)
@@ -97499,7 +97499,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32toMask8x32(v *ssa.Value) bool {
+func rewriteValue_OpCvt32toMask8x32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt32toMask8x32 <t> x)
@@ -97515,7 +97515,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97562,7 +97562,7 @@
}
return false
}
-func rewriteValueAMD64_OpCvt64Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -97607,7 +97607,7 @@
}
return false
}
-func rewriteValueAMD64_OpCvt64toMask8x64(v *ssa.Value) bool {
+func rewriteValue_OpCvt64toMask8x64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt64toMask8x64 <t> x)
@@ -97623,7 +97623,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask16x8(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask16x8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask16x8 <t> x)
@@ -97639,7 +97639,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask32x4(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask32x4 <t> x)
@@ -97655,7 +97655,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask32x8(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask32x8 <t> x)
@@ -97671,7 +97671,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask64x2(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask64x2 <t> x)
@@ -97687,7 +97687,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask64x4(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask64x4 <t> x)
@@ -97703,7 +97703,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt8toMask64x8(v *ssa.Value) bool {
+func rewriteValue_OpCvt8toMask64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Cvt8toMask64x8 <t> x)
@@ -97719,7 +97719,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask16x16to16(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask16x16to16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask16x16to16 x)
@@ -97733,7 +97733,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask16x32to32(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask16x32to32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask16x32to32 x)
@@ -97747,7 +97747,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask16x8to8(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask16x8to8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask16x8to8 x)
@@ -97761,7 +97761,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask32x16to16(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask32x16to16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask32x16to16 x)
@@ -97775,7 +97775,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask64x8to8(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask64x8to8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask64x8to8 x)
@@ -97789,7 +97789,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvtMask8x64to64(v *ssa.Value) bool {
+func rewriteValue_OpCvtMask8x64to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CvtMask8x64to64 x)
@@ -97803,7 +97803,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97822,7 +97822,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97839,7 +97839,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97858,7 +97858,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97875,7 +97875,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97894,7 +97894,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64u(v *ssa.Value) bool {
+func rewriteValue_OpDiv64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97911,7 +97911,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97932,7 +97932,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97953,7 +97953,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97969,7 +97969,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -97985,7 +97985,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98001,7 +98001,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98017,7 +98017,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98033,7 +98033,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98049,7 +98049,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98065,7 +98065,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98081,7 +98081,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98099,7 +98099,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqualFloat32x4 x y)
@@ -98113,7 +98113,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqualFloat32x8 x y)
@@ -98127,7 +98127,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqualFloat64x2 x y)
@@ -98141,7 +98141,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqualFloat64x4 x y)
@@ -98155,7 +98155,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpEqualFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98173,7 +98173,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpEqualInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98190,7 +98190,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpEqualInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98207,7 +98207,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpEqualInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98224,7 +98224,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpEqualInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98241,7 +98241,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpEqualUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98258,7 +98258,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpEqualUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98275,7 +98275,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpEqualUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98292,7 +98292,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqualUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpEqualUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98309,7 +98309,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98325,7 +98325,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98341,7 +98341,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98357,7 +98357,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98373,7 +98373,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98389,7 +98389,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98405,7 +98405,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98421,7 +98421,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98437,7 +98437,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98453,7 +98453,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98469,7 +98469,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98485,7 +98485,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98501,7 +98501,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98517,7 +98517,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98533,7 +98533,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98549,7 +98549,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98565,7 +98565,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98581,7 +98581,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpExpandInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98597,7 +98597,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98613,7 +98613,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98629,7 +98629,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98645,7 +98645,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98661,7 +98661,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98677,7 +98677,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98693,7 +98693,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98709,7 +98709,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98725,7 +98725,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98741,7 +98741,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98757,7 +98757,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98773,7 +98773,7 @@
return true
}
}
-func rewriteValueAMD64_OpExpandUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpExpandUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -98789,7 +98789,7 @@
return true
}
}
-func rewriteValueAMD64_OpFMA(v *ssa.Value) bool {
+func rewriteValue_OpFMA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -98804,7 +98804,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloor(v *ssa.Value) bool {
+func rewriteValue_OpFloor(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (ROUNDSD [1] x)
@@ -98816,7 +98816,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorFloat32x4 x)
// result: (VROUNDPS128 [1] x)
@@ -98828,7 +98828,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpFloorFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorFloat32x8 x)
// result: (VROUNDPS256 [1] x)
@@ -98840,7 +98840,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpFloorFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorFloat64x2 x)
// result: (VROUNDPD128 [1] x)
@@ -98852,7 +98852,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorFloat64x4 x)
// result: (VROUNDPD256 [1] x)
@@ -98864,7 +98864,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat32x16 [a] x)
// result: (VRNDSCALEPS512 [a+1] x)
@@ -98877,7 +98877,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat32x4 [a] x)
// result: (VRNDSCALEPS128 [a+1] x)
@@ -98890,7 +98890,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat32x8 [a] x)
// result: (VRNDSCALEPS256 [a+1] x)
@@ -98903,7 +98903,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat64x2 [a] x)
// result: (VRNDSCALEPD128 [a+1] x)
@@ -98916,7 +98916,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat64x4 [a] x)
// result: (VRNDSCALEPD256 [a+1] x)
@@ -98929,7 +98929,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledFloat64x8 [a] x)
// result: (VRNDSCALEPD512 [a+1] x)
@@ -98942,7 +98942,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat32x16 [a] x)
// result: (VREDUCEPS512 [a+1] x)
@@ -98955,7 +98955,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat32x4 [a] x)
// result: (VREDUCEPS128 [a+1] x)
@@ -98968,7 +98968,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat32x8 [a] x)
// result: (VREDUCEPS256 [a+1] x)
@@ -98981,7 +98981,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat64x2 [a] x)
// result: (VREDUCEPD128 [a+1] x)
@@ -98994,7 +98994,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat64x4 [a] x)
// result: (VREDUCEPD256 [a+1] x)
@@ -99007,7 +99007,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloorScaledResidueFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpFloorScaledResidueFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FloorScaledResidueFloat64x8 [a] x)
// result: (VREDUCEPD512 [a+1] x)
@@ -99020,7 +99020,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetG(v *ssa.Value) bool {
+func rewriteValue_OpGetG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetG mem)
// cond: v.Block.Func.OwnAux.Fn.ABI() != obj.ABIInternal
@@ -99036,7 +99036,7 @@
}
return false
}
-func rewriteValueAMD64_OpGetHiFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetHiFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiFloat32x16 x)
// result: (VEXTRACTF64X4256 [1] x)
@@ -99048,7 +99048,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiFloat32x8 x)
// result: (VEXTRACTF128128 [1] x)
@@ -99060,7 +99060,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetHiFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiFloat64x4 x)
// result: (VEXTRACTF128128 [1] x)
@@ -99072,7 +99072,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiFloat64x8 x)
// result: (VEXTRACTF64X4256 [1] x)
@@ -99084,7 +99084,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt16x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt16x16 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99096,7 +99096,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt16x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt16x32 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99108,7 +99108,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt32x16 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99120,7 +99120,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt32x8 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99132,7 +99132,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt64x4 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99144,7 +99144,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt64x8 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99156,7 +99156,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt8x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt8x32 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99168,7 +99168,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpGetHiInt8x64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiInt8x64 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99180,7 +99180,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint16x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint16x16 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99192,7 +99192,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint16x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint16x32 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99204,7 +99204,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint32x16 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99216,7 +99216,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint32x8 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99228,7 +99228,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint64x4 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99240,7 +99240,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint64x8 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99252,7 +99252,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint8x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint8x32 x)
// result: (VEXTRACTI128128 [1] x)
@@ -99264,7 +99264,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetHiUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpGetHiUint8x64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetHiUint8x64 x)
// result: (VEXTRACTI64X4256 [1] x)
@@ -99276,7 +99276,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetLoFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoFloat32x16 x)
// result: (VEXTRACTF64X4256 [0] x)
@@ -99288,7 +99288,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoFloat32x8 x)
// result: (VEXTRACTF128128 [0] x)
@@ -99300,7 +99300,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetLoFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoFloat64x4 x)
// result: (VEXTRACTF128128 [0] x)
@@ -99312,7 +99312,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoFloat64x8 x)
// result: (VEXTRACTF64X4256 [0] x)
@@ -99324,7 +99324,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt16x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt16x16 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99336,7 +99336,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt16x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt16x32 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99348,7 +99348,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt32x16 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99360,7 +99360,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt32x8 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99372,7 +99372,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt64x4 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99384,7 +99384,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt64x8 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99396,7 +99396,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt8x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt8x32 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99408,7 +99408,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpGetLoInt8x64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoInt8x64 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99420,7 +99420,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint16x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint16x16 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99432,7 +99432,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint16x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint16x32 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99444,7 +99444,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint32x16 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99456,7 +99456,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint32x8 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99468,7 +99468,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint64x4 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99480,7 +99480,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint64x8 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99492,7 +99492,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint8x32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint8x32 x)
// result: (VEXTRACTI128128 [0] x)
@@ -99504,7 +99504,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetLoUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpGetLoUint8x64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GetLoUint8x64 x)
// result: (VEXTRACTI64X4256 [0] x)
@@ -99516,7 +99516,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99534,7 +99534,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterEqualFloat32x4 x y)
@@ -99548,7 +99548,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterEqualFloat32x8 x y)
@@ -99562,7 +99562,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterEqualFloat64x2 x y)
@@ -99576,7 +99576,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterEqualFloat64x4 x y)
@@ -99590,7 +99590,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99608,7 +99608,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99626,7 +99626,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99644,7 +99644,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99662,7 +99662,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99680,7 +99680,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99698,7 +99698,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99716,7 +99716,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99734,7 +99734,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterEqualUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpGreaterEqualUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99752,7 +99752,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99770,7 +99770,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterFloat32x4 x y)
@@ -99784,7 +99784,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterFloat32x8 x y)
@@ -99798,7 +99798,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterFloat64x2 x y)
@@ -99812,7 +99812,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (GreaterFloat64x4 x y)
@@ -99826,7 +99826,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99844,7 +99844,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpGreaterInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99861,7 +99861,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99878,7 +99878,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99895,7 +99895,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpGreaterInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99912,7 +99912,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpGreaterUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99930,7 +99930,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpGreaterUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99948,7 +99948,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpGreaterUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99966,7 +99966,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreaterUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpGreaterUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -99984,7 +99984,7 @@
return true
}
}
-func rewriteValueAMD64_OpHasCPUFeature(v *ssa.Value) bool {
+func rewriteValue_OpHasCPUFeature(v *ssa.Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (HasCPUFeature {s})
@@ -100001,7 +100001,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100017,7 +100017,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -100033,7 +100033,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (IsNaNFloat32x4 x)
// result: (VCMPPS128 [3] x x)
@@ -100045,7 +100045,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (IsNaNFloat32x8 x)
// result: (VCMPPS256 [3] x x)
@@ -100057,7 +100057,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (IsNaNFloat64x2 x)
// result: (VCMPPD128 [3] x x)
@@ -100069,7 +100069,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (IsNaNFloat64x4 x)
// result: (VCMPPD256 [3] x x)
@@ -100081,7 +100081,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNaNFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpIsNaNFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -100097,7 +100097,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil p)
@@ -100111,7 +100111,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100127,7 +100127,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsZeroVec(v *ssa.Value) bool {
+func rewriteValue_OpIsZeroVec(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsZeroVec x)
@@ -100141,7 +100141,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100157,7 +100157,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100173,7 +100173,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100189,7 +100189,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100205,7 +100205,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100221,7 +100221,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100237,7 +100237,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100253,7 +100253,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100269,7 +100269,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100285,7 +100285,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100301,7 +100301,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100317,7 +100317,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100333,7 +100333,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100349,7 +100349,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100365,7 +100365,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100381,7 +100381,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100397,7 +100397,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100413,7 +100413,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100429,7 +100429,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100445,7 +100445,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100461,7 +100461,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100479,7 +100479,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessEqualFloat32x4 x y)
@@ -100493,7 +100493,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessEqualFloat32x8 x y)
@@ -100507,7 +100507,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessEqualFloat64x2 x y)
@@ -100521,7 +100521,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessEqualFloat64x4 x y)
@@ -100535,7 +100535,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100553,7 +100553,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100571,7 +100571,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100589,7 +100589,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100607,7 +100607,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100625,7 +100625,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100643,7 +100643,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100661,7 +100661,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100679,7 +100679,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessEqualUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpLessEqualUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100697,7 +100697,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100715,7 +100715,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessFloat32x4 x y)
@@ -100729,7 +100729,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessFloat32x8 x y)
@@ -100743,7 +100743,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessFloat64x2 x y)
@@ -100757,7 +100757,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LessFloat64x4 x y)
@@ -100771,7 +100771,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100789,7 +100789,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpLessInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100807,7 +100807,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100825,7 +100825,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100843,7 +100843,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpLessInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100861,7 +100861,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpLessUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100879,7 +100879,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpLessUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100897,7 +100897,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpLessUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100915,7 +100915,7 @@
return true
}
}
-func rewriteValueAMD64_OpLessUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpLessUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100933,7 +100933,7 @@
return true
}
}
-func rewriteValueAMD64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -101064,7 +101064,7 @@
}
return false
}
-func rewriteValueAMD64_OpLoadMasked16(v *ssa.Value) bool {
+func rewriteValue_OpLoadMasked16(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -101088,7 +101088,7 @@
}
return false
}
-func rewriteValueAMD64_OpLoadMasked32(v *ssa.Value) bool {
+func rewriteValue_OpLoadMasked32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -101142,7 +101142,7 @@
}
return false
}
-func rewriteValueAMD64_OpLoadMasked64(v *ssa.Value) bool {
+func rewriteValue_OpLoadMasked64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -101196,7 +101196,7 @@
}
return false
}
-func rewriteValueAMD64_OpLoadMasked8(v *ssa.Value) bool {
+func rewriteValue_OpLoadMasked8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -101220,7 +101220,7 @@
}
return false
}
-func rewriteValueAMD64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101260,7 +101260,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101300,7 +101300,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101340,7 +101340,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101380,7 +101380,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101420,7 +101420,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101460,7 +101460,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101500,7 +101500,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101540,7 +101540,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101580,7 +101580,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101620,7 +101620,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101660,7 +101660,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101700,7 +101700,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101740,7 +101740,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101780,7 +101780,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101820,7 +101820,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101860,7 +101860,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101900,7 +101900,7 @@
}
return false
}
-func rewriteValueAMD64_OpMax32F(v *ssa.Value) bool {
+func rewriteValue_OpMax32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101922,7 +101922,7 @@
return true
}
}
-func rewriteValueAMD64_OpMax64F(v *ssa.Value) bool {
+func rewriteValue_OpMax64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101944,7 +101944,7 @@
return true
}
}
-func rewriteValueAMD64_OpMin32F(v *ssa.Value) bool {
+func rewriteValue_OpMin32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101963,7 +101963,7 @@
return true
}
}
-func rewriteValueAMD64_OpMin64F(v *ssa.Value) bool {
+func rewriteValue_OpMin64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -101982,7 +101982,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102001,7 +102001,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102018,7 +102018,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102037,7 +102037,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102054,7 +102054,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102073,7 +102073,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64u(v *ssa.Value) bool {
+func rewriteValue_OpMod64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102090,7 +102090,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102111,7 +102111,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102132,7 +102132,7 @@
return true
}
}
-func rewriteValueAMD64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -102491,7 +102491,7 @@
}
return false
}
-func rewriteValueAMD64_OpMul64uhilo(v *ssa.Value) bool {
+func rewriteValue_OpMul64uhilo(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64uhilo x y)
@@ -102522,7 +102522,7 @@
}
return false
}
-func rewriteValueAMD64_OpNeg32F(v *ssa.Value) bool {
+func rewriteValue_OpNeg32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -102537,7 +102537,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg64F(v *ssa.Value) bool {
+func rewriteValue_OpNeg64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -102552,7 +102552,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102568,7 +102568,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102584,7 +102584,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102600,7 +102600,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102616,7 +102616,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102632,7 +102632,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102648,7 +102648,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqB(v *ssa.Value) bool {
+func rewriteValue_OpNeqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102664,7 +102664,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102680,7 +102680,7 @@
return true
}
}
-func rewriteValueAMD64_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORLconst [1] x)
@@ -102692,7 +102692,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102710,7 +102710,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NotEqualFloat32x4 x y)
@@ -102724,7 +102724,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NotEqualFloat32x8 x y)
@@ -102738,7 +102738,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NotEqualFloat64x2 x y)
@@ -102752,7 +102752,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NotEqualFloat64x4 x y)
@@ -102766,7 +102766,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102784,7 +102784,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102802,7 +102802,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102820,7 +102820,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102838,7 +102838,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102856,7 +102856,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102874,7 +102874,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102892,7 +102892,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102910,7 +102910,7 @@
return true
}
}
-func rewriteValueAMD64_OpNotEqualUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpNotEqualUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -102928,7 +102928,7 @@
return true
}
}
-func rewriteValueAMD64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -102958,7 +102958,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -102973,7 +102973,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -102988,7 +102988,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundFloat32x4 x)
// result: (VROUNDPS128 [0] x)
@@ -103000,7 +103000,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpRoundFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundFloat32x8 x)
// result: (VROUNDPS256 [0] x)
@@ -103012,7 +103012,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpRoundFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundFloat64x2 x)
// result: (VROUNDPD128 [0] x)
@@ -103024,7 +103024,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundFloat64x4 x)
// result: (VROUNDPD256 [0] x)
@@ -103036,7 +103036,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat32x16 [a] x)
// result: (VRNDSCALEPS512 [a+0] x)
@@ -103049,7 +103049,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat32x4 [a] x)
// result: (VRNDSCALEPS128 [a+0] x)
@@ -103062,7 +103062,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat32x8 [a] x)
// result: (VRNDSCALEPS256 [a+0] x)
@@ -103075,7 +103075,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat64x2 [a] x)
// result: (VRNDSCALEPD128 [a+0] x)
@@ -103088,7 +103088,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat64x4 [a] x)
// result: (VRNDSCALEPD256 [a+0] x)
@@ -103101,7 +103101,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledFloat64x8 [a] x)
// result: (VRNDSCALEPD512 [a+0] x)
@@ -103114,7 +103114,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat32x16 [a] x)
// result: (VREDUCEPS512 [a+0] x)
@@ -103127,7 +103127,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat32x4 [a] x)
// result: (VREDUCEPS128 [a+0] x)
@@ -103140,7 +103140,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat32x8 [a] x)
// result: (VREDUCEPS256 [a+0] x)
@@ -103153,7 +103153,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat64x2 [a] x)
// result: (VREDUCEPD128 [a+0] x)
@@ -103166,7 +103166,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat64x4 [a] x)
// result: (VREDUCEPD256 [a+0] x)
@@ -103179,7 +103179,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundScaledResidueFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpRoundScaledResidueFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundScaledResidueFloat64x8 [a] x)
// result: (VREDUCEPD512 [a+0] x)
@@ -103192,7 +103192,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundToEven(v *ssa.Value) bool {
+func rewriteValue_OpRoundToEven(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (ROUNDSD [0] x)
@@ -103204,7 +103204,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103244,7 +103244,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103284,7 +103284,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103324,7 +103324,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103364,7 +103364,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103407,7 +103407,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103450,7 +103450,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103493,7 +103493,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103536,7 +103536,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103576,7 +103576,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103616,7 +103616,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103656,7 +103656,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103696,7 +103696,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103739,7 +103739,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103782,7 +103782,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103825,7 +103825,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103868,7 +103868,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103908,7 +103908,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103948,7 +103948,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -103988,7 +103988,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104028,7 +104028,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104071,7 +104071,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104114,7 +104114,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104157,7 +104157,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104200,7 +104200,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104240,7 +104240,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104280,7 +104280,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104320,7 +104320,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104360,7 +104360,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104403,7 +104403,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104446,7 +104446,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104489,7 +104489,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -104532,7 +104532,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -104672,7 +104672,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -104925,7 +104925,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelectN(v *ssa.Value) bool {
+func rewriteValue_OpSelectN(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -104997,7 +104997,7 @@
}
return false
}
-func rewriteValueAMD64_OpSetHiFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetHiFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiFloat32x16 x y)
@@ -105011,7 +105011,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiFloat32x8 x y)
@@ -105025,7 +105025,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetHiFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiFloat64x4 x y)
@@ -105039,7 +105039,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiFloat64x8 x y)
@@ -105053,7 +105053,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt16x16 x y)
@@ -105067,7 +105067,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt16x32 x y)
@@ -105081,7 +105081,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt32x16 x y)
@@ -105095,7 +105095,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt32x8 x y)
@@ -105109,7 +105109,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt64x4 x y)
@@ -105123,7 +105123,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt64x8 x y)
@@ -105137,7 +105137,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt8x32 x y)
@@ -105151,7 +105151,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpSetHiInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiInt8x64 x y)
@@ -105165,7 +105165,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint16x16 x y)
@@ -105179,7 +105179,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint16x32 x y)
@@ -105193,7 +105193,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint32x16 x y)
@@ -105207,7 +105207,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint32x8 x y)
@@ -105221,7 +105221,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint64x4 x y)
@@ -105235,7 +105235,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint64x8 x y)
@@ -105249,7 +105249,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint8x32 x y)
@@ -105263,7 +105263,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetHiUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpSetHiUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetHiUint8x64 x y)
@@ -105277,7 +105277,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetLoFloat32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoFloat32x16 x y)
@@ -105291,7 +105291,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoFloat32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoFloat32x8 x y)
@@ -105305,7 +105305,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetLoFloat64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoFloat64x4 x y)
@@ -105319,7 +105319,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoFloat64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoFloat64x8 x y)
@@ -105333,7 +105333,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt16x16(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt16x16 x y)
@@ -105347,7 +105347,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt16x32 x y)
@@ -105361,7 +105361,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt32x16 x y)
@@ -105375,7 +105375,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt32x8 x y)
@@ -105389,7 +105389,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt64x4 x y)
@@ -105403,7 +105403,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt64x8 x y)
@@ -105417,7 +105417,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt8x32(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt8x32 x y)
@@ -105431,7 +105431,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpSetLoInt8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoInt8x64 x y)
@@ -105445,7 +105445,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint16x16(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint16x16 x y)
@@ -105459,7 +105459,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint16x32(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint16x32 x y)
@@ -105473,7 +105473,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint32x16(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint32x16 x y)
@@ -105487,7 +105487,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint32x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint32x8 x y)
@@ -105501,7 +105501,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint64x4(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint64x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint64x4 x y)
@@ -105515,7 +105515,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint64x8(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint64x8 x y)
@@ -105529,7 +105529,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint8x32(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint8x32 x y)
@@ -105543,7 +105543,7 @@
return true
}
}
-func rewriteValueAMD64_OpSetLoUint8x64(v *ssa.Value) bool {
+func rewriteValue_OpSetLoUint8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SetLoUint8x64 x y)
@@ -105557,7 +105557,7 @@
return true
}
}
-func rewriteValueAMD64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -105573,7 +105573,7 @@
return true
}
}
-func rewriteValueAMD64_OpSpectreIndex(v *ssa.Value) bool {
+func rewriteValue_OpSpectreIndex(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -105592,7 +105592,7 @@
return true
}
}
-func rewriteValueAMD64_OpSpectreSliceIndex(v *ssa.Value) bool {
+func rewriteValue_OpSpectreSliceIndex(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -105611,7 +105611,7 @@
return true
}
}
-func rewriteValueAMD64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -105752,7 +105752,7 @@
}
return false
}
-func rewriteValueAMD64_OpStoreMasked16(v *ssa.Value) bool {
+func rewriteValue_OpStoreMasked16(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -105778,7 +105778,7 @@
}
return false
}
-func rewriteValueAMD64_OpStoreMasked32(v *ssa.Value) bool {
+func rewriteValue_OpStoreMasked32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -105836,7 +105836,7 @@
}
return false
}
-func rewriteValueAMD64_OpStoreMasked64(v *ssa.Value) bool {
+func rewriteValue_OpStoreMasked64(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -105894,7 +105894,7 @@
}
return false
}
-func rewriteValueAMD64_OpStoreMasked8(v *ssa.Value) bool {
+func rewriteValue_OpStoreMasked8(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -105920,7 +105920,7 @@
}
return false
}
-func rewriteValueAMD64_OpTrunc(v *ssa.Value) bool {
+func rewriteValue_OpTrunc(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (ROUNDSD [3] x)
@@ -105932,7 +105932,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncFloat32x4 x)
// result: (VROUNDPS128 [3] x)
@@ -105944,7 +105944,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpTruncFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncFloat32x8 x)
// result: (VROUNDPS256 [3] x)
@@ -105956,7 +105956,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpTruncFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncFloat64x2 x)
// result: (VROUNDPD128 [3] x)
@@ -105968,7 +105968,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncFloat64x4 x)
// result: (VROUNDPD256 [3] x)
@@ -105980,7 +105980,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat32x16 [a] x)
// result: (VRNDSCALEPS512 [a+3] x)
@@ -105993,7 +105993,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat32x4 [a] x)
// result: (VRNDSCALEPS128 [a+3] x)
@@ -106006,7 +106006,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat32x8 [a] x)
// result: (VRNDSCALEPS256 [a+3] x)
@@ -106019,7 +106019,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat64x2 [a] x)
// result: (VRNDSCALEPD128 [a+3] x)
@@ -106032,7 +106032,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat64x4 [a] x)
// result: (VRNDSCALEPD256 [a+3] x)
@@ -106045,7 +106045,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledFloat64x8 [a] x)
// result: (VRNDSCALEPD512 [a+3] x)
@@ -106058,7 +106058,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat32x16(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat32x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat32x16 [a] x)
// result: (VREDUCEPS512 [a+3] x)
@@ -106071,7 +106071,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat32x4 [a] x)
// result: (VREDUCEPS128 [a+3] x)
@@ -106084,7 +106084,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat32x8(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat32x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat32x8 [a] x)
// result: (VREDUCEPS256 [a+3] x)
@@ -106097,7 +106097,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat64x2 [a] x)
// result: (VREDUCEPD128 [a+3] x)
@@ -106110,7 +106110,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat64x4(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat64x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat64x4 [a] x)
// result: (VREDUCEPD256 [a+3] x)
@@ -106123,7 +106123,7 @@
return true
}
}
-func rewriteValueAMD64_OpTruncScaledResidueFloat64x8(v *ssa.Value) bool {
+func rewriteValue_OpTruncScaledResidueFloat64x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TruncScaledResidueFloat64x8 [a] x)
// result: (VREDUCEPD512 [a+3] x)
@@ -106136,7 +106136,7 @@
return true
}
}
-func rewriteValueAMD64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106420,7 +106420,7 @@
}
return false
}
-func rewriteValueAMD64_OpZeroSIMD(v *ssa.Value) bool {
+func rewriteValue_OpZeroSIMD(v *ssa.Value) bool {
// match: (ZeroSIMD <t>)
// cond: t.Size() == 16
// result: (Zero128 <t>)
@@ -106459,7 +106459,7 @@
}
return false
}
-func rewriteValueAMD64_OpblendMaskedInt16x32(v *ssa.Value) bool {
+func rewriteValue_OpblendMaskedInt16x32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -106477,7 +106477,7 @@
return true
}
}
-func rewriteValueAMD64_OpblendMaskedInt32x16(v *ssa.Value) bool {
+func rewriteValue_OpblendMaskedInt32x16(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -106495,7 +106495,7 @@
return true
}
}
-func rewriteValueAMD64_OpblendMaskedInt64x8(v *ssa.Value) bool {
+func rewriteValue_OpblendMaskedInt64x8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -106513,7 +106513,7 @@
return true
}
}
-func rewriteValueAMD64_OpblendMaskedInt8x64(v *ssa.Value) bool {
+func rewriteValue_OpblendMaskedInt8x64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -106531,7 +106531,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedFloat32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106547,7 +106547,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedInt16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106563,7 +106563,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedInt32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106579,7 +106579,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedInt8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106595,7 +106595,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedUint16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106611,7 +106611,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedUint32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106627,7 +106627,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To16MaskedUint8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16MaskedUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106643,7 +106643,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To2MaskedFloat64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2MaskedFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106659,7 +106659,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To2MaskedInt64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2MaskedInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106675,7 +106675,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To2MaskedUint64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2MaskedUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106691,7 +106691,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To32MaskedInt16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To32MaskedInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106707,7 +106707,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To32MaskedInt8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To32MaskedInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106723,7 +106723,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To32MaskedUint16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To32MaskedUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106739,7 +106739,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To32MaskedUint8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To32MaskedUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106755,7 +106755,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedFloat32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106771,7 +106771,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedFloat64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106787,7 +106787,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedInt32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106803,7 +106803,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedInt64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106819,7 +106819,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedUint32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106835,7 +106835,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To4MaskedUint64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4MaskedUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106851,7 +106851,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To64MaskedInt8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To64MaskedInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106867,7 +106867,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To64MaskedUint8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To64MaskedUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106883,7 +106883,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedFloat32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedFloat32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106899,7 +106899,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedFloat64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedFloat64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106915,7 +106915,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedInt16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106931,7 +106931,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedInt32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106947,7 +106947,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedInt64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106963,7 +106963,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedUint16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106979,7 +106979,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedUint32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -106995,7 +106995,7 @@
return true
}
}
-func rewriteValueAMD64_Opbroadcast1To8MaskedUint64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8MaskedUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -107011,7 +107011,7 @@
return true
}
}
-func rewriteBlockAMD64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockAMD64EQ:
diff --git a/src/cmd/compile/internal/ssacompile/rewriteAMD64latelower.go b/src/cmd/compile/internal/ssarewrite/rewriteamd64latelower/rewriteAMD64latelower.go
similarity index 69%
rename from src/cmd/compile/internal/ssacompile/rewriteAMD64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewriteamd64latelower/rewriteAMD64latelower.go
index a4ea29d..d22bb9b 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteAMD64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteamd64latelower/rewriteAMD64latelower.go
@@ -1,35 +1,35 @@
// Code generated from _gen/AMD64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteamd64latelower
import "internal/buildcfg"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueAMD64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAMD64MOVBQZX:
- return rewriteValueAMD64latelower_OpAMD64MOVBQZX(v)
+ return rewriteValue_OpAMD64MOVBQZX(v)
case ssaop.OpAMD64MOVLQZX:
- return rewriteValueAMD64latelower_OpAMD64MOVLQZX(v)
+ return rewriteValue_OpAMD64MOVLQZX(v)
case ssaop.OpAMD64MOVWQZX:
- return rewriteValueAMD64latelower_OpAMD64MOVWQZX(v)
+ return rewriteValue_OpAMD64MOVWQZX(v)
case ssaop.OpAMD64SARL:
- return rewriteValueAMD64latelower_OpAMD64SARL(v)
+ return rewriteValue_OpAMD64SARL(v)
case ssaop.OpAMD64SARQ:
- return rewriteValueAMD64latelower_OpAMD64SARQ(v)
+ return rewriteValue_OpAMD64SARQ(v)
case ssaop.OpAMD64SHLL:
- return rewriteValueAMD64latelower_OpAMD64SHLL(v)
+ return rewriteValue_OpAMD64SHLL(v)
case ssaop.OpAMD64SHLQ:
- return rewriteValueAMD64latelower_OpAMD64SHLQ(v)
+ return rewriteValue_OpAMD64SHLQ(v)
case ssaop.OpAMD64SHRL:
- return rewriteValueAMD64latelower_OpAMD64SHRL(v)
+ return rewriteValue_OpAMD64SHRL(v)
case ssaop.OpAMD64SHRQ:
- return rewriteValueAMD64latelower_OpAMD64SHRQ(v)
+ return rewriteValue_OpAMD64SHRQ(v)
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64MOVBQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVBQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBQZX x)
// cond: ssa.ZeroUpper56Bits(x)
@@ -44,7 +44,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64MOVLQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVLQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVLQZX x)
// cond: ssa.ZeroUpper32Bits(x)
@@ -59,7 +59,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64MOVWQZX(v *ssa.Value) bool {
+func rewriteValue_OpAMD64MOVWQZX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWQZX x)
// cond: ssa.ZeroUpper48Bits(x)
@@ -74,7 +74,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SARL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARL x y)
@@ -92,7 +92,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SARQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SARQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARQ x y)
@@ -110,7 +110,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SHLL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHLL x y)
@@ -128,7 +128,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SHLQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHLQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHLQ x y)
@@ -146,7 +146,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SHRL(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRL x y)
@@ -164,7 +164,7 @@
}
return false
}
-func rewriteValueAMD64latelower_OpAMD64SHRQ(v *ssa.Value) bool {
+func rewriteValue_OpAMD64SHRQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRQ x y)
@@ -182,6 +182,6 @@
}
return false
}
-func rewriteBlockAMD64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/rewriteAMD64splitload.go b/src/cmd/compile/internal/ssarewrite/rewriteamd64splitload/rewriteAMD64splitload.go
similarity index 86%
rename from src/cmd/compile/internal/ssacompile/rewriteAMD64splitload.go
rename to src/cmd/compile/internal/ssarewrite/rewriteamd64splitload/rewriteAMD64splitload.go
index 3061d33..b282079 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteAMD64splitload.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteamd64splitload/rewriteAMD64splitload.go
@@ -1,60 +1,60 @@
// Code generated from _gen/AMD64splitload.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteamd64splitload
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueAMD64splitload(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAMD64CMPBconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPBconstload(v)
+ return rewriteValue_OpAMD64CMPBconstload(v)
case ssaop.OpAMD64CMPBconstloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v)
+ return rewriteValue_OpAMD64CMPBconstloadidx1(v)
case ssaop.OpAMD64CMPBload:
- return rewriteValueAMD64splitload_OpAMD64CMPBload(v)
+ return rewriteValue_OpAMD64CMPBload(v)
case ssaop.OpAMD64CMPBloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPBloadidx1(v)
+ return rewriteValue_OpAMD64CMPBloadidx1(v)
case ssaop.OpAMD64CMPLconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPLconstload(v)
+ return rewriteValue_OpAMD64CMPLconstload(v)
case ssaop.OpAMD64CMPLconstloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v)
+ return rewriteValue_OpAMD64CMPLconstloadidx1(v)
case ssaop.OpAMD64CMPLconstloadidx4:
- return rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v)
+ return rewriteValue_OpAMD64CMPLconstloadidx4(v)
case ssaop.OpAMD64CMPLload:
- return rewriteValueAMD64splitload_OpAMD64CMPLload(v)
+ return rewriteValue_OpAMD64CMPLload(v)
case ssaop.OpAMD64CMPLloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPLloadidx1(v)
+ return rewriteValue_OpAMD64CMPLloadidx1(v)
case ssaop.OpAMD64CMPLloadidx4:
- return rewriteValueAMD64splitload_OpAMD64CMPLloadidx4(v)
+ return rewriteValue_OpAMD64CMPLloadidx4(v)
case ssaop.OpAMD64CMPQconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPQconstload(v)
+ return rewriteValue_OpAMD64CMPQconstload(v)
case ssaop.OpAMD64CMPQconstloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v)
+ return rewriteValue_OpAMD64CMPQconstloadidx1(v)
case ssaop.OpAMD64CMPQconstloadidx8:
- return rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v)
+ return rewriteValue_OpAMD64CMPQconstloadidx8(v)
case ssaop.OpAMD64CMPQload:
- return rewriteValueAMD64splitload_OpAMD64CMPQload(v)
+ return rewriteValue_OpAMD64CMPQload(v)
case ssaop.OpAMD64CMPQloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPQloadidx1(v)
+ return rewriteValue_OpAMD64CMPQloadidx1(v)
case ssaop.OpAMD64CMPQloadidx8:
- return rewriteValueAMD64splitload_OpAMD64CMPQloadidx8(v)
+ return rewriteValue_OpAMD64CMPQloadidx8(v)
case ssaop.OpAMD64CMPWconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPWconstload(v)
+ return rewriteValue_OpAMD64CMPWconstload(v)
case ssaop.OpAMD64CMPWconstloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v)
+ return rewriteValue_OpAMD64CMPWconstloadidx1(v)
case ssaop.OpAMD64CMPWconstloadidx2:
- return rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v)
+ return rewriteValue_OpAMD64CMPWconstloadidx2(v)
case ssaop.OpAMD64CMPWload:
- return rewriteValueAMD64splitload_OpAMD64CMPWload(v)
+ return rewriteValue_OpAMD64CMPWload(v)
case ssaop.OpAMD64CMPWloadidx1:
- return rewriteValueAMD64splitload_OpAMD64CMPWloadidx1(v)
+ return rewriteValue_OpAMD64CMPWloadidx1(v)
case ssaop.OpAMD64CMPWloadidx2:
- return rewriteValueAMD64splitload_OpAMD64CMPWloadidx2(v)
+ return rewriteValue_OpAMD64CMPWloadidx2(v)
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -100,7 +100,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBconstloadidx1(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -149,7 +149,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPBload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -171,7 +171,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPBloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPBloadidx1(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -195,7 +195,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -241,7 +241,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLconstloadidx1(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -290,7 +290,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLconstloadidx4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -339,7 +339,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPLload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -361,7 +361,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPLloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLloadidx1(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -385,7 +385,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPLloadidx4(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPLloadidx4(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -409,7 +409,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -455,7 +455,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQconstloadidx1(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -504,7 +504,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQconstloadidx8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -553,7 +553,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPQload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -575,7 +575,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPQloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQloadidx1(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -599,7 +599,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPQloadidx8(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPQloadidx8(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -623,7 +623,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWconstload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -669,7 +669,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWconstloadidx1(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -718,7 +718,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWconstloadidx2(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -767,7 +767,7 @@
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPWload(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -789,7 +789,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPWloadidx1(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWloadidx1(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -813,7 +813,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPWloadidx2(v *ssa.Value) bool {
+func rewriteValue_OpAMD64CMPWloadidx2(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -837,6 +837,6 @@
return true
}
}
-func rewriteBlockAMD64splitload(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/arm_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritearm/arm_helpers.go
similarity index 94%
rename from src/cmd/compile/internal/ssacompile/arm_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm/arm_helpers.go
index 015974d..0da4c37 100644
--- a/src/cmd/compile/internal/ssacompile/arm_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm/arm_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritearm
// check if an immediate can be directly encoded into an ARM's instruction.
func isARMImmRot(v uint32) bool {
diff --git a/src/cmd/compile/internal/ssacompile/rewriteARM.go b/src/cmd/compile/internal/ssarewrite/rewritearm/rewriteARM.go
similarity index 93%
rename from src/cmd/compile/internal/ssacompile/rewriteARM.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm/rewriteARM.go
index 2861f8c..dca916d 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteARM.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm/rewriteARM.go
@@ -1,6 +1,6 @@
// Code generated from _gen/ARM.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritearm
import "internal/buildcfg"
import "cmd/compile/internal/types"
@@ -8,432 +8,432 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueARM(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpARMADC:
- return rewriteValueARM_OpARMADC(v)
+ return rewriteValue_OpARMADC(v)
case ssaop.OpARMADCconst:
- return rewriteValueARM_OpARMADCconst(v)
+ return rewriteValue_OpARMADCconst(v)
case ssaop.OpARMADCshiftLL:
- return rewriteValueARM_OpARMADCshiftLL(v)
+ return rewriteValue_OpARMADCshiftLL(v)
case ssaop.OpARMADCshiftLLreg:
- return rewriteValueARM_OpARMADCshiftLLreg(v)
+ return rewriteValue_OpARMADCshiftLLreg(v)
case ssaop.OpARMADCshiftRA:
- return rewriteValueARM_OpARMADCshiftRA(v)
+ return rewriteValue_OpARMADCshiftRA(v)
case ssaop.OpARMADCshiftRAreg:
- return rewriteValueARM_OpARMADCshiftRAreg(v)
+ return rewriteValue_OpARMADCshiftRAreg(v)
case ssaop.OpARMADCshiftRL:
- return rewriteValueARM_OpARMADCshiftRL(v)
+ return rewriteValue_OpARMADCshiftRL(v)
case ssaop.OpARMADCshiftRLreg:
- return rewriteValueARM_OpARMADCshiftRLreg(v)
+ return rewriteValue_OpARMADCshiftRLreg(v)
case ssaop.OpARMADD:
- return rewriteValueARM_OpARMADD(v)
+ return rewriteValue_OpARMADD(v)
case ssaop.OpARMADDD:
- return rewriteValueARM_OpARMADDD(v)
+ return rewriteValue_OpARMADDD(v)
case ssaop.OpARMADDF:
- return rewriteValueARM_OpARMADDF(v)
+ return rewriteValue_OpARMADDF(v)
case ssaop.OpARMADDS:
- return rewriteValueARM_OpARMADDS(v)
+ return rewriteValue_OpARMADDS(v)
case ssaop.OpARMADDSshiftLL:
- return rewriteValueARM_OpARMADDSshiftLL(v)
+ return rewriteValue_OpARMADDSshiftLL(v)
case ssaop.OpARMADDSshiftLLreg:
- return rewriteValueARM_OpARMADDSshiftLLreg(v)
+ return rewriteValue_OpARMADDSshiftLLreg(v)
case ssaop.OpARMADDSshiftRA:
- return rewriteValueARM_OpARMADDSshiftRA(v)
+ return rewriteValue_OpARMADDSshiftRA(v)
case ssaop.OpARMADDSshiftRAreg:
- return rewriteValueARM_OpARMADDSshiftRAreg(v)
+ return rewriteValue_OpARMADDSshiftRAreg(v)
case ssaop.OpARMADDSshiftRL:
- return rewriteValueARM_OpARMADDSshiftRL(v)
+ return rewriteValue_OpARMADDSshiftRL(v)
case ssaop.OpARMADDSshiftRLreg:
- return rewriteValueARM_OpARMADDSshiftRLreg(v)
+ return rewriteValue_OpARMADDSshiftRLreg(v)
case ssaop.OpARMADDconst:
- return rewriteValueARM_OpARMADDconst(v)
+ return rewriteValue_OpARMADDconst(v)
case ssaop.OpARMADDshiftLL:
- return rewriteValueARM_OpARMADDshiftLL(v)
+ return rewriteValue_OpARMADDshiftLL(v)
case ssaop.OpARMADDshiftLLreg:
- return rewriteValueARM_OpARMADDshiftLLreg(v)
+ return rewriteValue_OpARMADDshiftLLreg(v)
case ssaop.OpARMADDshiftRA:
- return rewriteValueARM_OpARMADDshiftRA(v)
+ return rewriteValue_OpARMADDshiftRA(v)
case ssaop.OpARMADDshiftRAreg:
- return rewriteValueARM_OpARMADDshiftRAreg(v)
+ return rewriteValue_OpARMADDshiftRAreg(v)
case ssaop.OpARMADDshiftRL:
- return rewriteValueARM_OpARMADDshiftRL(v)
+ return rewriteValue_OpARMADDshiftRL(v)
case ssaop.OpARMADDshiftRLreg:
- return rewriteValueARM_OpARMADDshiftRLreg(v)
+ return rewriteValue_OpARMADDshiftRLreg(v)
case ssaop.OpARMAND:
- return rewriteValueARM_OpARMAND(v)
+ return rewriteValue_OpARMAND(v)
case ssaop.OpARMANDconst:
- return rewriteValueARM_OpARMANDconst(v)
+ return rewriteValue_OpARMANDconst(v)
case ssaop.OpARMANDshiftLL:
- return rewriteValueARM_OpARMANDshiftLL(v)
+ return rewriteValue_OpARMANDshiftLL(v)
case ssaop.OpARMANDshiftLLreg:
- return rewriteValueARM_OpARMANDshiftLLreg(v)
+ return rewriteValue_OpARMANDshiftLLreg(v)
case ssaop.OpARMANDshiftRA:
- return rewriteValueARM_OpARMANDshiftRA(v)
+ return rewriteValue_OpARMANDshiftRA(v)
case ssaop.OpARMANDshiftRAreg:
- return rewriteValueARM_OpARMANDshiftRAreg(v)
+ return rewriteValue_OpARMANDshiftRAreg(v)
case ssaop.OpARMANDshiftRL:
- return rewriteValueARM_OpARMANDshiftRL(v)
+ return rewriteValue_OpARMANDshiftRL(v)
case ssaop.OpARMANDshiftRLreg:
- return rewriteValueARM_OpARMANDshiftRLreg(v)
+ return rewriteValue_OpARMANDshiftRLreg(v)
case ssaop.OpARMBFX:
- return rewriteValueARM_OpARMBFX(v)
+ return rewriteValue_OpARMBFX(v)
case ssaop.OpARMBFXU:
- return rewriteValueARM_OpARMBFXU(v)
+ return rewriteValue_OpARMBFXU(v)
case ssaop.OpARMBIC:
- return rewriteValueARM_OpARMBIC(v)
+ return rewriteValue_OpARMBIC(v)
case ssaop.OpARMBICconst:
- return rewriteValueARM_OpARMBICconst(v)
+ return rewriteValue_OpARMBICconst(v)
case ssaop.OpARMBICshiftLL:
- return rewriteValueARM_OpARMBICshiftLL(v)
+ return rewriteValue_OpARMBICshiftLL(v)
case ssaop.OpARMBICshiftLLreg:
- return rewriteValueARM_OpARMBICshiftLLreg(v)
+ return rewriteValue_OpARMBICshiftLLreg(v)
case ssaop.OpARMBICshiftRA:
- return rewriteValueARM_OpARMBICshiftRA(v)
+ return rewriteValue_OpARMBICshiftRA(v)
case ssaop.OpARMBICshiftRAreg:
- return rewriteValueARM_OpARMBICshiftRAreg(v)
+ return rewriteValue_OpARMBICshiftRAreg(v)
case ssaop.OpARMBICshiftRL:
- return rewriteValueARM_OpARMBICshiftRL(v)
+ return rewriteValue_OpARMBICshiftRL(v)
case ssaop.OpARMBICshiftRLreg:
- return rewriteValueARM_OpARMBICshiftRLreg(v)
+ return rewriteValue_OpARMBICshiftRLreg(v)
case ssaop.OpARMCMN:
- return rewriteValueARM_OpARMCMN(v)
+ return rewriteValue_OpARMCMN(v)
case ssaop.OpARMCMNconst:
- return rewriteValueARM_OpARMCMNconst(v)
+ return rewriteValue_OpARMCMNconst(v)
case ssaop.OpARMCMNshiftLL:
- return rewriteValueARM_OpARMCMNshiftLL(v)
+ return rewriteValue_OpARMCMNshiftLL(v)
case ssaop.OpARMCMNshiftLLreg:
- return rewriteValueARM_OpARMCMNshiftLLreg(v)
+ return rewriteValue_OpARMCMNshiftLLreg(v)
case ssaop.OpARMCMNshiftRA:
- return rewriteValueARM_OpARMCMNshiftRA(v)
+ return rewriteValue_OpARMCMNshiftRA(v)
case ssaop.OpARMCMNshiftRAreg:
- return rewriteValueARM_OpARMCMNshiftRAreg(v)
+ return rewriteValue_OpARMCMNshiftRAreg(v)
case ssaop.OpARMCMNshiftRL:
- return rewriteValueARM_OpARMCMNshiftRL(v)
+ return rewriteValue_OpARMCMNshiftRL(v)
case ssaop.OpARMCMNshiftRLreg:
- return rewriteValueARM_OpARMCMNshiftRLreg(v)
+ return rewriteValue_OpARMCMNshiftRLreg(v)
case ssaop.OpARMCMOVWHSconst:
- return rewriteValueARM_OpARMCMOVWHSconst(v)
+ return rewriteValue_OpARMCMOVWHSconst(v)
case ssaop.OpARMCMOVWLSconst:
- return rewriteValueARM_OpARMCMOVWLSconst(v)
+ return rewriteValue_OpARMCMOVWLSconst(v)
case ssaop.OpARMCMP:
- return rewriteValueARM_OpARMCMP(v)
+ return rewriteValue_OpARMCMP(v)
case ssaop.OpARMCMPD:
- return rewriteValueARM_OpARMCMPD(v)
+ return rewriteValue_OpARMCMPD(v)
case ssaop.OpARMCMPF:
- return rewriteValueARM_OpARMCMPF(v)
+ return rewriteValue_OpARMCMPF(v)
case ssaop.OpARMCMPconst:
- return rewriteValueARM_OpARMCMPconst(v)
+ return rewriteValue_OpARMCMPconst(v)
case ssaop.OpARMCMPshiftLL:
- return rewriteValueARM_OpARMCMPshiftLL(v)
+ return rewriteValue_OpARMCMPshiftLL(v)
case ssaop.OpARMCMPshiftLLreg:
- return rewriteValueARM_OpARMCMPshiftLLreg(v)
+ return rewriteValue_OpARMCMPshiftLLreg(v)
case ssaop.OpARMCMPshiftRA:
- return rewriteValueARM_OpARMCMPshiftRA(v)
+ return rewriteValue_OpARMCMPshiftRA(v)
case ssaop.OpARMCMPshiftRAreg:
- return rewriteValueARM_OpARMCMPshiftRAreg(v)
+ return rewriteValue_OpARMCMPshiftRAreg(v)
case ssaop.OpARMCMPshiftRL:
- return rewriteValueARM_OpARMCMPshiftRL(v)
+ return rewriteValue_OpARMCMPshiftRL(v)
case ssaop.OpARMCMPshiftRLreg:
- return rewriteValueARM_OpARMCMPshiftRLreg(v)
+ return rewriteValue_OpARMCMPshiftRLreg(v)
case ssaop.OpARMEqual:
- return rewriteValueARM_OpARMEqual(v)
+ return rewriteValue_OpARMEqual(v)
case ssaop.OpARMGreaterEqual:
- return rewriteValueARM_OpARMGreaterEqual(v)
+ return rewriteValue_OpARMGreaterEqual(v)
case ssaop.OpARMGreaterEqualU:
- return rewriteValueARM_OpARMGreaterEqualU(v)
+ return rewriteValue_OpARMGreaterEqualU(v)
case ssaop.OpARMGreaterThan:
- return rewriteValueARM_OpARMGreaterThan(v)
+ return rewriteValue_OpARMGreaterThan(v)
case ssaop.OpARMGreaterThanU:
- return rewriteValueARM_OpARMGreaterThanU(v)
+ return rewriteValue_OpARMGreaterThanU(v)
case ssaop.OpARMLessEqual:
- return rewriteValueARM_OpARMLessEqual(v)
+ return rewriteValue_OpARMLessEqual(v)
case ssaop.OpARMLessEqualU:
- return rewriteValueARM_OpARMLessEqualU(v)
+ return rewriteValue_OpARMLessEqualU(v)
case ssaop.OpARMLessThan:
- return rewriteValueARM_OpARMLessThan(v)
+ return rewriteValue_OpARMLessThan(v)
case ssaop.OpARMLessThanU:
- return rewriteValueARM_OpARMLessThanU(v)
+ return rewriteValue_OpARMLessThanU(v)
case ssaop.OpARMLoweredPanicBoundsRC:
- return rewriteValueARM_OpARMLoweredPanicBoundsRC(v)
+ return rewriteValue_OpARMLoweredPanicBoundsRC(v)
case ssaop.OpARMLoweredPanicBoundsRR:
- return rewriteValueARM_OpARMLoweredPanicBoundsRR(v)
+ return rewriteValue_OpARMLoweredPanicBoundsRR(v)
case ssaop.OpARMLoweredPanicExtendRC:
- return rewriteValueARM_OpARMLoweredPanicExtendRC(v)
+ return rewriteValue_OpARMLoweredPanicExtendRC(v)
case ssaop.OpARMLoweredPanicExtendRR:
- return rewriteValueARM_OpARMLoweredPanicExtendRR(v)
+ return rewriteValue_OpARMLoweredPanicExtendRR(v)
case ssaop.OpARMMOVBUload:
- return rewriteValueARM_OpARMMOVBUload(v)
+ return rewriteValue_OpARMMOVBUload(v)
case ssaop.OpARMMOVBUloadidx:
- return rewriteValueARM_OpARMMOVBUloadidx(v)
+ return rewriteValue_OpARMMOVBUloadidx(v)
case ssaop.OpARMMOVBUreg:
- return rewriteValueARM_OpARMMOVBUreg(v)
+ return rewriteValue_OpARMMOVBUreg(v)
case ssaop.OpARMMOVBload:
- return rewriteValueARM_OpARMMOVBload(v)
+ return rewriteValue_OpARMMOVBload(v)
case ssaop.OpARMMOVBloadidx:
- return rewriteValueARM_OpARMMOVBloadidx(v)
+ return rewriteValue_OpARMMOVBloadidx(v)
case ssaop.OpARMMOVBreg:
- return rewriteValueARM_OpARMMOVBreg(v)
+ return rewriteValue_OpARMMOVBreg(v)
case ssaop.OpARMMOVBstore:
- return rewriteValueARM_OpARMMOVBstore(v)
+ return rewriteValue_OpARMMOVBstore(v)
case ssaop.OpARMMOVBstoreidx:
- return rewriteValueARM_OpARMMOVBstoreidx(v)
+ return rewriteValue_OpARMMOVBstoreidx(v)
case ssaop.OpARMMOVDload:
- return rewriteValueARM_OpARMMOVDload(v)
+ return rewriteValue_OpARMMOVDload(v)
case ssaop.OpARMMOVDstore:
- return rewriteValueARM_OpARMMOVDstore(v)
+ return rewriteValue_OpARMMOVDstore(v)
case ssaop.OpARMMOVFload:
- return rewriteValueARM_OpARMMOVFload(v)
+ return rewriteValue_OpARMMOVFload(v)
case ssaop.OpARMMOVFstore:
- return rewriteValueARM_OpARMMOVFstore(v)
+ return rewriteValue_OpARMMOVFstore(v)
case ssaop.OpARMMOVHUload:
- return rewriteValueARM_OpARMMOVHUload(v)
+ return rewriteValue_OpARMMOVHUload(v)
case ssaop.OpARMMOVHUloadidx:
- return rewriteValueARM_OpARMMOVHUloadidx(v)
+ return rewriteValue_OpARMMOVHUloadidx(v)
case ssaop.OpARMMOVHUreg:
- return rewriteValueARM_OpARMMOVHUreg(v)
+ return rewriteValue_OpARMMOVHUreg(v)
case ssaop.OpARMMOVHload:
- return rewriteValueARM_OpARMMOVHload(v)
+ return rewriteValue_OpARMMOVHload(v)
case ssaop.OpARMMOVHloadidx:
- return rewriteValueARM_OpARMMOVHloadidx(v)
+ return rewriteValue_OpARMMOVHloadidx(v)
case ssaop.OpARMMOVHreg:
- return rewriteValueARM_OpARMMOVHreg(v)
+ return rewriteValue_OpARMMOVHreg(v)
case ssaop.OpARMMOVHstore:
- return rewriteValueARM_OpARMMOVHstore(v)
+ return rewriteValue_OpARMMOVHstore(v)
case ssaop.OpARMMOVHstoreidx:
- return rewriteValueARM_OpARMMOVHstoreidx(v)
+ return rewriteValue_OpARMMOVHstoreidx(v)
case ssaop.OpARMMOVWload:
- return rewriteValueARM_OpARMMOVWload(v)
+ return rewriteValue_OpARMMOVWload(v)
case ssaop.OpARMMOVWloadidx:
- return rewriteValueARM_OpARMMOVWloadidx(v)
+ return rewriteValue_OpARMMOVWloadidx(v)
case ssaop.OpARMMOVWloadshiftLL:
- return rewriteValueARM_OpARMMOVWloadshiftLL(v)
+ return rewriteValue_OpARMMOVWloadshiftLL(v)
case ssaop.OpARMMOVWloadshiftRA:
- return rewriteValueARM_OpARMMOVWloadshiftRA(v)
+ return rewriteValue_OpARMMOVWloadshiftRA(v)
case ssaop.OpARMMOVWloadshiftRL:
- return rewriteValueARM_OpARMMOVWloadshiftRL(v)
+ return rewriteValue_OpARMMOVWloadshiftRL(v)
case ssaop.OpARMMOVWnop:
- return rewriteValueARM_OpARMMOVWnop(v)
+ return rewriteValue_OpARMMOVWnop(v)
case ssaop.OpARMMOVWreg:
- return rewriteValueARM_OpARMMOVWreg(v)
+ return rewriteValue_OpARMMOVWreg(v)
case ssaop.OpARMMOVWstore:
- return rewriteValueARM_OpARMMOVWstore(v)
+ return rewriteValue_OpARMMOVWstore(v)
case ssaop.OpARMMOVWstoreidx:
- return rewriteValueARM_OpARMMOVWstoreidx(v)
+ return rewriteValue_OpARMMOVWstoreidx(v)
case ssaop.OpARMMOVWstoreshiftLL:
- return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
+ return rewriteValue_OpARMMOVWstoreshiftLL(v)
case ssaop.OpARMMOVWstoreshiftRA:
- return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
+ return rewriteValue_OpARMMOVWstoreshiftRA(v)
case ssaop.OpARMMOVWstoreshiftRL:
- return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
+ return rewriteValue_OpARMMOVWstoreshiftRL(v)
case ssaop.OpARMMUL:
- return rewriteValueARM_OpARMMUL(v)
+ return rewriteValue_OpARMMUL(v)
case ssaop.OpARMMULA:
- return rewriteValueARM_OpARMMULA(v)
+ return rewriteValue_OpARMMULA(v)
case ssaop.OpARMMULD:
- return rewriteValueARM_OpARMMULD(v)
+ return rewriteValue_OpARMMULD(v)
case ssaop.OpARMMULF:
- return rewriteValueARM_OpARMMULF(v)
+ return rewriteValue_OpARMMULF(v)
case ssaop.OpARMMULS:
- return rewriteValueARM_OpARMMULS(v)
+ return rewriteValue_OpARMMULS(v)
case ssaop.OpARMMVN:
- return rewriteValueARM_OpARMMVN(v)
+ return rewriteValue_OpARMMVN(v)
case ssaop.OpARMMVNshiftLL:
- return rewriteValueARM_OpARMMVNshiftLL(v)
+ return rewriteValue_OpARMMVNshiftLL(v)
case ssaop.OpARMMVNshiftLLreg:
- return rewriteValueARM_OpARMMVNshiftLLreg(v)
+ return rewriteValue_OpARMMVNshiftLLreg(v)
case ssaop.OpARMMVNshiftRA:
- return rewriteValueARM_OpARMMVNshiftRA(v)
+ return rewriteValue_OpARMMVNshiftRA(v)
case ssaop.OpARMMVNshiftRAreg:
- return rewriteValueARM_OpARMMVNshiftRAreg(v)
+ return rewriteValue_OpARMMVNshiftRAreg(v)
case ssaop.OpARMMVNshiftRL:
- return rewriteValueARM_OpARMMVNshiftRL(v)
+ return rewriteValue_OpARMMVNshiftRL(v)
case ssaop.OpARMMVNshiftRLreg:
- return rewriteValueARM_OpARMMVNshiftRLreg(v)
+ return rewriteValue_OpARMMVNshiftRLreg(v)
case ssaop.OpARMNEGD:
- return rewriteValueARM_OpARMNEGD(v)
+ return rewriteValue_OpARMNEGD(v)
case ssaop.OpARMNEGF:
- return rewriteValueARM_OpARMNEGF(v)
+ return rewriteValue_OpARMNEGF(v)
case ssaop.OpARMNMULD:
- return rewriteValueARM_OpARMNMULD(v)
+ return rewriteValue_OpARMNMULD(v)
case ssaop.OpARMNMULF:
- return rewriteValueARM_OpARMNMULF(v)
+ return rewriteValue_OpARMNMULF(v)
case ssaop.OpARMNotEqual:
- return rewriteValueARM_OpARMNotEqual(v)
+ return rewriteValue_OpARMNotEqual(v)
case ssaop.OpARMOR:
- return rewriteValueARM_OpARMOR(v)
+ return rewriteValue_OpARMOR(v)
case ssaop.OpARMORconst:
- return rewriteValueARM_OpARMORconst(v)
+ return rewriteValue_OpARMORconst(v)
case ssaop.OpARMORshiftLL:
- return rewriteValueARM_OpARMORshiftLL(v)
+ return rewriteValue_OpARMORshiftLL(v)
case ssaop.OpARMORshiftLLreg:
- return rewriteValueARM_OpARMORshiftLLreg(v)
+ return rewriteValue_OpARMORshiftLLreg(v)
case ssaop.OpARMORshiftRA:
- return rewriteValueARM_OpARMORshiftRA(v)
+ return rewriteValue_OpARMORshiftRA(v)
case ssaop.OpARMORshiftRAreg:
- return rewriteValueARM_OpARMORshiftRAreg(v)
+ return rewriteValue_OpARMORshiftRAreg(v)
case ssaop.OpARMORshiftRL:
- return rewriteValueARM_OpARMORshiftRL(v)
+ return rewriteValue_OpARMORshiftRL(v)
case ssaop.OpARMORshiftRLreg:
- return rewriteValueARM_OpARMORshiftRLreg(v)
+ return rewriteValue_OpARMORshiftRLreg(v)
case ssaop.OpARMRSB:
- return rewriteValueARM_OpARMRSB(v)
+ return rewriteValue_OpARMRSB(v)
case ssaop.OpARMRSBSshiftLL:
- return rewriteValueARM_OpARMRSBSshiftLL(v)
+ return rewriteValue_OpARMRSBSshiftLL(v)
case ssaop.OpARMRSBSshiftLLreg:
- return rewriteValueARM_OpARMRSBSshiftLLreg(v)
+ return rewriteValue_OpARMRSBSshiftLLreg(v)
case ssaop.OpARMRSBSshiftRA:
- return rewriteValueARM_OpARMRSBSshiftRA(v)
+ return rewriteValue_OpARMRSBSshiftRA(v)
case ssaop.OpARMRSBSshiftRAreg:
- return rewriteValueARM_OpARMRSBSshiftRAreg(v)
+ return rewriteValue_OpARMRSBSshiftRAreg(v)
case ssaop.OpARMRSBSshiftRL:
- return rewriteValueARM_OpARMRSBSshiftRL(v)
+ return rewriteValue_OpARMRSBSshiftRL(v)
case ssaop.OpARMRSBSshiftRLreg:
- return rewriteValueARM_OpARMRSBSshiftRLreg(v)
+ return rewriteValue_OpARMRSBSshiftRLreg(v)
case ssaop.OpARMRSBconst:
- return rewriteValueARM_OpARMRSBconst(v)
+ return rewriteValue_OpARMRSBconst(v)
case ssaop.OpARMRSBshiftLL:
- return rewriteValueARM_OpARMRSBshiftLL(v)
+ return rewriteValue_OpARMRSBshiftLL(v)
case ssaop.OpARMRSBshiftLLreg:
- return rewriteValueARM_OpARMRSBshiftLLreg(v)
+ return rewriteValue_OpARMRSBshiftLLreg(v)
case ssaop.OpARMRSBshiftRA:
- return rewriteValueARM_OpARMRSBshiftRA(v)
+ return rewriteValue_OpARMRSBshiftRA(v)
case ssaop.OpARMRSBshiftRAreg:
- return rewriteValueARM_OpARMRSBshiftRAreg(v)
+ return rewriteValue_OpARMRSBshiftRAreg(v)
case ssaop.OpARMRSBshiftRL:
- return rewriteValueARM_OpARMRSBshiftRL(v)
+ return rewriteValue_OpARMRSBshiftRL(v)
case ssaop.OpARMRSBshiftRLreg:
- return rewriteValueARM_OpARMRSBshiftRLreg(v)
+ return rewriteValue_OpARMRSBshiftRLreg(v)
case ssaop.OpARMRSCconst:
- return rewriteValueARM_OpARMRSCconst(v)
+ return rewriteValue_OpARMRSCconst(v)
case ssaop.OpARMRSCshiftLL:
- return rewriteValueARM_OpARMRSCshiftLL(v)
+ return rewriteValue_OpARMRSCshiftLL(v)
case ssaop.OpARMRSCshiftLLreg:
- return rewriteValueARM_OpARMRSCshiftLLreg(v)
+ return rewriteValue_OpARMRSCshiftLLreg(v)
case ssaop.OpARMRSCshiftRA:
- return rewriteValueARM_OpARMRSCshiftRA(v)
+ return rewriteValue_OpARMRSCshiftRA(v)
case ssaop.OpARMRSCshiftRAreg:
- return rewriteValueARM_OpARMRSCshiftRAreg(v)
+ return rewriteValue_OpARMRSCshiftRAreg(v)
case ssaop.OpARMRSCshiftRL:
- return rewriteValueARM_OpARMRSCshiftRL(v)
+ return rewriteValue_OpARMRSCshiftRL(v)
case ssaop.OpARMRSCshiftRLreg:
- return rewriteValueARM_OpARMRSCshiftRLreg(v)
+ return rewriteValue_OpARMRSCshiftRLreg(v)
case ssaop.OpARMSBC:
- return rewriteValueARM_OpARMSBC(v)
+ return rewriteValue_OpARMSBC(v)
case ssaop.OpARMSBCconst:
- return rewriteValueARM_OpARMSBCconst(v)
+ return rewriteValue_OpARMSBCconst(v)
case ssaop.OpARMSBCshiftLL:
- return rewriteValueARM_OpARMSBCshiftLL(v)
+ return rewriteValue_OpARMSBCshiftLL(v)
case ssaop.OpARMSBCshiftLLreg:
- return rewriteValueARM_OpARMSBCshiftLLreg(v)
+ return rewriteValue_OpARMSBCshiftLLreg(v)
case ssaop.OpARMSBCshiftRA:
- return rewriteValueARM_OpARMSBCshiftRA(v)
+ return rewriteValue_OpARMSBCshiftRA(v)
case ssaop.OpARMSBCshiftRAreg:
- return rewriteValueARM_OpARMSBCshiftRAreg(v)
+ return rewriteValue_OpARMSBCshiftRAreg(v)
case ssaop.OpARMSBCshiftRL:
- return rewriteValueARM_OpARMSBCshiftRL(v)
+ return rewriteValue_OpARMSBCshiftRL(v)
case ssaop.OpARMSBCshiftRLreg:
- return rewriteValueARM_OpARMSBCshiftRLreg(v)
+ return rewriteValue_OpARMSBCshiftRLreg(v)
case ssaop.OpARMSLL:
- return rewriteValueARM_OpARMSLL(v)
+ return rewriteValue_OpARMSLL(v)
case ssaop.OpARMSLLconst:
- return rewriteValueARM_OpARMSLLconst(v)
+ return rewriteValue_OpARMSLLconst(v)
case ssaop.OpARMSRA:
- return rewriteValueARM_OpARMSRA(v)
+ return rewriteValue_OpARMSRA(v)
case ssaop.OpARMSRAcond:
- return rewriteValueARM_OpARMSRAcond(v)
+ return rewriteValue_OpARMSRAcond(v)
case ssaop.OpARMSRAconst:
- return rewriteValueARM_OpARMSRAconst(v)
+ return rewriteValue_OpARMSRAconst(v)
case ssaop.OpARMSRL:
- return rewriteValueARM_OpARMSRL(v)
+ return rewriteValue_OpARMSRL(v)
case ssaop.OpARMSRLconst:
- return rewriteValueARM_OpARMSRLconst(v)
+ return rewriteValue_OpARMSRLconst(v)
case ssaop.OpARMSRR:
- return rewriteValueARM_OpARMSRR(v)
+ return rewriteValue_OpARMSRR(v)
case ssaop.OpARMSUB:
- return rewriteValueARM_OpARMSUB(v)
+ return rewriteValue_OpARMSUB(v)
case ssaop.OpARMSUBD:
- return rewriteValueARM_OpARMSUBD(v)
+ return rewriteValue_OpARMSUBD(v)
case ssaop.OpARMSUBF:
- return rewriteValueARM_OpARMSUBF(v)
+ return rewriteValue_OpARMSUBF(v)
case ssaop.OpARMSUBS:
- return rewriteValueARM_OpARMSUBS(v)
+ return rewriteValue_OpARMSUBS(v)
case ssaop.OpARMSUBSshiftLL:
- return rewriteValueARM_OpARMSUBSshiftLL(v)
+ return rewriteValue_OpARMSUBSshiftLL(v)
case ssaop.OpARMSUBSshiftLLreg:
- return rewriteValueARM_OpARMSUBSshiftLLreg(v)
+ return rewriteValue_OpARMSUBSshiftLLreg(v)
case ssaop.OpARMSUBSshiftRA:
- return rewriteValueARM_OpARMSUBSshiftRA(v)
+ return rewriteValue_OpARMSUBSshiftRA(v)
case ssaop.OpARMSUBSshiftRAreg:
- return rewriteValueARM_OpARMSUBSshiftRAreg(v)
+ return rewriteValue_OpARMSUBSshiftRAreg(v)
case ssaop.OpARMSUBSshiftRL:
- return rewriteValueARM_OpARMSUBSshiftRL(v)
+ return rewriteValue_OpARMSUBSshiftRL(v)
case ssaop.OpARMSUBSshiftRLreg:
- return rewriteValueARM_OpARMSUBSshiftRLreg(v)
+ return rewriteValue_OpARMSUBSshiftRLreg(v)
case ssaop.OpARMSUBconst:
- return rewriteValueARM_OpARMSUBconst(v)
+ return rewriteValue_OpARMSUBconst(v)
case ssaop.OpARMSUBshiftLL:
- return rewriteValueARM_OpARMSUBshiftLL(v)
+ return rewriteValue_OpARMSUBshiftLL(v)
case ssaop.OpARMSUBshiftLLreg:
- return rewriteValueARM_OpARMSUBshiftLLreg(v)
+ return rewriteValue_OpARMSUBshiftLLreg(v)
case ssaop.OpARMSUBshiftRA:
- return rewriteValueARM_OpARMSUBshiftRA(v)
+ return rewriteValue_OpARMSUBshiftRA(v)
case ssaop.OpARMSUBshiftRAreg:
- return rewriteValueARM_OpARMSUBshiftRAreg(v)
+ return rewriteValue_OpARMSUBshiftRAreg(v)
case ssaop.OpARMSUBshiftRL:
- return rewriteValueARM_OpARMSUBshiftRL(v)
+ return rewriteValue_OpARMSUBshiftRL(v)
case ssaop.OpARMSUBshiftRLreg:
- return rewriteValueARM_OpARMSUBshiftRLreg(v)
+ return rewriteValue_OpARMSUBshiftRLreg(v)
case ssaop.OpARMTEQ:
- return rewriteValueARM_OpARMTEQ(v)
+ return rewriteValue_OpARMTEQ(v)
case ssaop.OpARMTEQconst:
- return rewriteValueARM_OpARMTEQconst(v)
+ return rewriteValue_OpARMTEQconst(v)
case ssaop.OpARMTEQshiftLL:
- return rewriteValueARM_OpARMTEQshiftLL(v)
+ return rewriteValue_OpARMTEQshiftLL(v)
case ssaop.OpARMTEQshiftLLreg:
- return rewriteValueARM_OpARMTEQshiftLLreg(v)
+ return rewriteValue_OpARMTEQshiftLLreg(v)
case ssaop.OpARMTEQshiftRA:
- return rewriteValueARM_OpARMTEQshiftRA(v)
+ return rewriteValue_OpARMTEQshiftRA(v)
case ssaop.OpARMTEQshiftRAreg:
- return rewriteValueARM_OpARMTEQshiftRAreg(v)
+ return rewriteValue_OpARMTEQshiftRAreg(v)
case ssaop.OpARMTEQshiftRL:
- return rewriteValueARM_OpARMTEQshiftRL(v)
+ return rewriteValue_OpARMTEQshiftRL(v)
case ssaop.OpARMTEQshiftRLreg:
- return rewriteValueARM_OpARMTEQshiftRLreg(v)
+ return rewriteValue_OpARMTEQshiftRLreg(v)
case ssaop.OpARMTST:
- return rewriteValueARM_OpARMTST(v)
+ return rewriteValue_OpARMTST(v)
case ssaop.OpARMTSTconst:
- return rewriteValueARM_OpARMTSTconst(v)
+ return rewriteValue_OpARMTSTconst(v)
case ssaop.OpARMTSTshiftLL:
- return rewriteValueARM_OpARMTSTshiftLL(v)
+ return rewriteValue_OpARMTSTshiftLL(v)
case ssaop.OpARMTSTshiftLLreg:
- return rewriteValueARM_OpARMTSTshiftLLreg(v)
+ return rewriteValue_OpARMTSTshiftLLreg(v)
case ssaop.OpARMTSTshiftRA:
- return rewriteValueARM_OpARMTSTshiftRA(v)
+ return rewriteValue_OpARMTSTshiftRA(v)
case ssaop.OpARMTSTshiftRAreg:
- return rewriteValueARM_OpARMTSTshiftRAreg(v)
+ return rewriteValue_OpARMTSTshiftRAreg(v)
case ssaop.OpARMTSTshiftRL:
- return rewriteValueARM_OpARMTSTshiftRL(v)
+ return rewriteValue_OpARMTSTshiftRL(v)
case ssaop.OpARMTSTshiftRLreg:
- return rewriteValueARM_OpARMTSTshiftRLreg(v)
+ return rewriteValue_OpARMTSTshiftRLreg(v)
case ssaop.OpARMXOR:
- return rewriteValueARM_OpARMXOR(v)
+ return rewriteValue_OpARMXOR(v)
case ssaop.OpARMXORconst:
- return rewriteValueARM_OpARMXORconst(v)
+ return rewriteValue_OpARMXORconst(v)
case ssaop.OpARMXORshiftLL:
- return rewriteValueARM_OpARMXORshiftLL(v)
+ return rewriteValue_OpARMXORshiftLL(v)
case ssaop.OpARMXORshiftLLreg:
- return rewriteValueARM_OpARMXORshiftLLreg(v)
+ return rewriteValue_OpARMXORshiftLLreg(v)
case ssaop.OpARMXORshiftRA:
- return rewriteValueARM_OpARMXORshiftRA(v)
+ return rewriteValue_OpARMXORshiftRA(v)
case ssaop.OpARMXORshiftRAreg:
- return rewriteValueARM_OpARMXORshiftRAreg(v)
+ return rewriteValue_OpARMXORshiftRAreg(v)
case ssaop.OpARMXORshiftRL:
- return rewriteValueARM_OpARMXORshiftRL(v)
+ return rewriteValue_OpARMXORshiftRL(v)
case ssaop.OpARMXORshiftRLreg:
- return rewriteValueARM_OpARMXORshiftRLreg(v)
+ return rewriteValue_OpARMXORshiftRLreg(v)
case ssaop.OpARMXORshiftRR:
- return rewriteValueARM_OpARMXORshiftRR(v)
+ return rewriteValue_OpARMXORshiftRR(v)
case ssaop.OpAbs:
v.Op = ssaop.OpARMABSD
return true
@@ -465,7 +465,7 @@
v.Op = ssaop.OpARMADD
return true
case ssaop.OpAddr:
- return rewriteValueARM_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpARMAND
return true
@@ -479,15 +479,15 @@
v.Op = ssaop.OpARMAND
return true
case ssaop.OpAvg32u:
- return rewriteValueARM_OpAvg32u(v)
+ return rewriteValue_OpAvg32u(v)
case ssaop.OpBitLen16:
- return rewriteValueARM_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueARM_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen8:
- return rewriteValueARM_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBswap32:
- return rewriteValueARM_OpBswap32(v)
+ return rewriteValue_OpBswap32(v)
case ssaop.OpClosureCall:
v.Op = ssaop.OpARMCALLclosure
return true
@@ -501,31 +501,31 @@
v.Op = ssaop.OpARMMVN
return true
case ssaop.OpConst16:
- return rewriteValueARM_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueARM_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
- return rewriteValueARM_OpConst32F(v)
+ return rewriteValue_OpConst32F(v)
case ssaop.OpConst64F:
- return rewriteValueARM_OpConst64F(v)
+ return rewriteValue_OpConst64F(v)
case ssaop.OpConst8:
- return rewriteValueARM_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueARM_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueARM_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCtz16:
- return rewriteValueARM_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz32:
- return rewriteValueARM_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz8:
- return rewriteValueARM_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz32
return true
@@ -563,39 +563,39 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueARM_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueARM_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueARM_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpARMDIVF
return true
case ssaop.OpDiv32u:
- return rewriteValueARM_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpARMDIVD
return true
case ssaop.OpDiv8:
- return rewriteValueARM_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueARM_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueARM_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueARM_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueARM_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64F:
- return rewriteValueARM_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueARM_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueARM_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueARM_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpFMA:
- return rewriteValueARM_OpFMA(v)
+ return rewriteValue_OpFMA(v)
case ssaop.OpGetCallerPC:
v.Op = ssaop.OpARMLoweredGetCallerPC
return true
@@ -615,85 +615,85 @@
v.Op = ssaop.OpARMCALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValueARM_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueARM_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueARM_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValueARM_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueARM_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueARM_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueARM_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueARM_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64F:
- return rewriteValueARM_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq8:
- return rewriteValueARM_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueARM_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueARM_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueARM_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueARM_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueARM_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueARM_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64F:
- return rewriteValueARM_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess8:
- return rewriteValueARM_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueARM_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueARM_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueARM_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueARM_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueARM_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueARM_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueARM_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueARM_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueARM_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueARM_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueARM_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueARM_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueARM_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueARM_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueARM_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMod16:
- return rewriteValueARM_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueARM_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueARM_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueARM_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod8:
- return rewriteValueARM_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueARM_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueARM_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpARMMUL
return true
@@ -713,9 +713,9 @@
v.Op = ssaop.OpARMMUL
return true
case ssaop.OpNeg16:
- return rewriteValueARM_OpNeg16(v)
+ return rewriteValue_OpNeg16(v)
case ssaop.OpNeg32:
- return rewriteValueARM_OpNeg32(v)
+ return rewriteValue_OpNeg32(v)
case ssaop.OpNeg32F:
v.Op = ssaop.OpARMNEGF
return true
@@ -723,29 +723,29 @@
v.Op = ssaop.OpARMNEGD
return true
case ssaop.OpNeg8:
- return rewriteValueARM_OpNeg8(v)
+ return rewriteValue_OpNeg8(v)
case ssaop.OpNeq16:
- return rewriteValueARM_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueARM_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueARM_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64F:
- return rewriteValueARM_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueARM_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpARMXOR
return true
case ssaop.OpNeqPtr:
- return rewriteValueARM_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpARMLoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueARM_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValueARM_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpARMOR
return true
@@ -765,11 +765,11 @@
v.Op = ssaop.OpARMLoweredPanicExtendRR
return true
case ssaop.OpRotateLeft16:
- return rewriteValueARM_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValueARM_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft8:
- return rewriteValueARM_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpCopy
return true
@@ -777,57 +777,57 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueARM_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueARM_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueARM_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueARM_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueARM_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueARM_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueARM_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueARM_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueARM_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueARM_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueARM_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueARM_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueARM_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueARM_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueARM_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueARM_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueARM_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueARM_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueARM_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueARM_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueARM_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueARM_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueARM_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueARM_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueARM_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueARM_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpARMMOVHreg
return true
@@ -838,9 +838,9 @@
v.Op = ssaop.OpARMMOVBreg
return true
case ssaop.OpSignmask:
- return rewriteValueARM_OpSignmask(v)
+ return rewriteValue_OpSignmask(v)
case ssaop.OpSlicemask:
- return rewriteValueARM_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpARMSQRTD
return true
@@ -851,7 +851,7 @@
v.Op = ssaop.OpARMCALLstatic
return true
case ssaop.OpStore:
- return rewriteValueARM_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpARMSUB
return true
@@ -904,7 +904,7 @@
v.Op = ssaop.OpARMXOR
return true
case ssaop.OpZero:
- return rewriteValueARM_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpARMMOVHUreg
return true
@@ -915,11 +915,11 @@
v.Op = ssaop.OpARMMOVBUreg
return true
case ssaop.OpZeromask:
- return rewriteValueARM_OpZeromask(v)
+ return rewriteValue_OpZeromask(v)
}
return false
}
-func rewriteValueARM_OpARMADC(v *ssa.Value) bool {
+func rewriteValue_OpARMADC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1047,7 +1047,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCconst(v *ssa.Value) bool {
+func rewriteValue_OpARMADCconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADCconst [c] (ADDconst [d] x) flags)
@@ -1082,7 +1082,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftLL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1122,7 +1122,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftLLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1166,7 +1166,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftRA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1206,7 +1206,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftRAreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1250,7 +1250,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftRL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1290,7 +1290,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADCshiftRLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1334,7 +1334,7 @@
}
return false
}
-func rewriteValueARM_OpARMADD(v *ssa.Value) bool {
+func rewriteValue_OpARMADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1515,7 +1515,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDD(v *ssa.Value) bool {
+func rewriteValue_OpARMADDD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDD a (MULD x y))
@@ -1560,7 +1560,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDF(v *ssa.Value) bool {
+func rewriteValue_OpARMADDF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDF a (MULF x y))
@@ -1605,7 +1605,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDS(v *ssa.Value) bool {
+func rewriteValue_OpARMADDS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDS x (MOVWconst [c]))
@@ -1725,7 +1725,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1762,7 +1762,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1803,7 +1803,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1840,7 +1840,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1881,7 +1881,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1918,7 +1918,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDSshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1959,7 +1959,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDconst(v *ssa.Value) bool {
+func rewriteValue_OpARMADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2071,7 +2071,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2142,7 +2142,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2183,7 +2183,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2220,7 +2220,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2261,7 +2261,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2298,7 +2298,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMADDshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2339,7 +2339,7 @@
}
return false
}
-func rewriteValueARM_OpARMAND(v *ssa.Value) bool {
+func rewriteValue_OpARMAND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVWconst [c]))
@@ -2535,7 +2535,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDconst(v *ssa.Value) bool {
+func rewriteValue_OpARMANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVWconst [0])
@@ -2615,7 +2615,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2667,7 +2667,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2708,7 +2708,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2760,7 +2760,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2801,7 +2801,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2853,7 +2853,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMANDshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2894,7 +2894,7 @@
}
return false
}
-func rewriteValueARM_OpARMBFX(v *ssa.Value) bool {
+func rewriteValue_OpARMBFX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BFX [c] (MOVWconst [d]))
// result: (MOVWconst [d<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8))])
@@ -2910,7 +2910,7 @@
}
return false
}
-func rewriteValueARM_OpARMBFXU(v *ssa.Value) bool {
+func rewriteValue_OpARMBFXU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BFXU [c] (MOVWconst [d]))
// result: (MOVWconst [int32(uint32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))])
@@ -2926,7 +2926,7 @@
}
return false
}
-func rewriteValueARM_OpARMBIC(v *ssa.Value) bool {
+func rewriteValue_OpARMBIC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BIC x (MOVWconst [c]))
@@ -3036,7 +3036,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICconst(v *ssa.Value) bool {
+func rewriteValue_OpARMBICconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BICconst [0] x)
// result: x
@@ -3116,7 +3116,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftLL x (MOVWconst [c]) [d])
@@ -3150,7 +3150,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3174,7 +3174,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRA x (MOVWconst [c]) [d])
@@ -3208,7 +3208,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3232,7 +3232,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRL x (MOVWconst [c]) [d])
@@ -3266,7 +3266,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMBICshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3290,7 +3290,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMN(v *ssa.Value) bool {
+func rewriteValue_OpARMCMN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMN x (MOVWconst [c]))
@@ -3410,7 +3410,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNconst(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMNconst (MOVWconst [x]) [y])
// result: (FlagConstant [ssa.AddFlags32(x,y)])
@@ -3426,7 +3426,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3463,7 +3463,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3504,7 +3504,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3541,7 +3541,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3582,7 +3582,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3619,7 +3619,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMNshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3660,7 +3660,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWHSconst(v *ssa.Value) bool {
+func rewriteValue_OpARMCMOVWHSconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVWHSconst _ (FlagConstant [fc]) [c])
@@ -3710,7 +3710,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWLSconst(v *ssa.Value) bool {
+func rewriteValue_OpARMCMOVWLSconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVWLSconst _ (FlagConstant [fc]) [c])
@@ -3760,7 +3760,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMP(v *ssa.Value) bool {
+func rewriteValue_OpARMCMP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3983,7 +3983,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPD(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPD x (MOVDconst [0]))
@@ -3999,7 +3999,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPF(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPF x (MOVFconst [0]))
@@ -4015,7 +4015,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPconst(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVWconst [x]) [y])
// result: (FlagConstant [ssa.SubFlags32(x,y)])
@@ -4087,7 +4087,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4126,7 +4126,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4169,7 +4169,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4208,7 +4208,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4251,7 +4251,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4290,7 +4290,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMCMPshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4333,7 +4333,7 @@
}
return false
}
-func rewriteValueARM_OpARMEqual(v *ssa.Value) bool {
+func rewriteValue_OpARMEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Equal (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Eq())])
@@ -4359,7 +4359,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqual(v *ssa.Value) bool {
+func rewriteValue_OpARMGreaterEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqual (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Ge())])
@@ -4385,7 +4385,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqualU(v *ssa.Value) bool {
+func rewriteValue_OpARMGreaterEqualU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualU (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Uge())])
@@ -4411,7 +4411,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThan(v *ssa.Value) bool {
+func rewriteValue_OpARMGreaterThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterThan (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Gt())])
@@ -4437,7 +4437,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThanU(v *ssa.Value) bool {
+func rewriteValue_OpARMGreaterThanU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanU (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Ugt())])
@@ -4463,7 +4463,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqual(v *ssa.Value) bool {
+func rewriteValue_OpARMLessEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessEqual (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Le())])
@@ -4489,7 +4489,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqualU(v *ssa.Value) bool {
+func rewriteValue_OpARMLessEqualU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessEqualU (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Ule())])
@@ -4515,7 +4515,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThan(v *ssa.Value) bool {
+func rewriteValue_OpARMLessThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThan (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Lt())])
@@ -4541,7 +4541,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThanU(v *ssa.Value) bool {
+func rewriteValue_OpARMLessThanU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThanU (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Ult())])
@@ -4567,7 +4567,7 @@
}
return false
}
-func rewriteValueARM_OpARMLoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpARMLoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVWconst [c]) mem)
@@ -4588,7 +4588,7 @@
}
return false
}
-func rewriteValueARM_OpARMLoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpARMLoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4626,7 +4626,7 @@
}
return false
}
-func rewriteValueARM_OpARMLoweredPanicExtendRC(v *ssa.Value) bool {
+func rewriteValue_OpARMLoweredPanicExtendRC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4652,7 +4652,7 @@
}
return false
}
-func rewriteValueARM_OpARMLoweredPanicExtendRR(v *ssa.Value) bool {
+func rewriteValue_OpARMLoweredPanicExtendRR(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -4696,7 +4696,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -4812,7 +4812,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4864,7 +4864,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(MOVBUload _ _))
// result: (MOVWreg x)
@@ -4914,7 +4914,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5030,7 +5030,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5082,7 +5082,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVWreg x)
@@ -5136,7 +5136,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5291,7 +5291,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVBstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -5328,7 +5328,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5409,7 +5409,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5474,7 +5474,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVFload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5555,7 +5555,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFstore(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVFstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5620,7 +5620,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5738,7 +5738,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5790,7 +5790,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x:(MOVBUload _ _))
// result: (MOVWreg x)
@@ -5862,7 +5862,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5980,7 +5980,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6032,7 +6032,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVWreg x)
@@ -6130,7 +6130,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6251,7 +6251,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVHstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6288,7 +6288,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWload(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6474,7 +6474,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6615,7 +6615,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWloadshiftLL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6655,7 +6655,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWloadshiftRA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6695,7 +6695,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWloadshiftRL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6735,7 +6735,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWnop(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWnop (MOVWconst [c]))
// result: (MOVWconst [c])
@@ -6750,7 +6750,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x)
// cond: x.Uses == 1
@@ -6777,7 +6777,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6936,7 +6936,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7069,7 +7069,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWstoreshiftLL(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7092,7 +7092,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWstoreshiftRA(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7115,7 +7115,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMMOVWstoreshiftRL(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7138,7 +7138,7 @@
}
return false
}
-func rewriteValueARM_OpARMMUL(v *ssa.Value) bool {
+func rewriteValue_OpARMMUL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7360,7 +7360,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULA(v *ssa.Value) bool {
+func rewriteValue_OpARMMULA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7766,7 +7766,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULD(v *ssa.Value) bool {
+func rewriteValue_OpARMMULD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULD (NEGD x) y)
@@ -7790,7 +7790,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULF(v *ssa.Value) bool {
+func rewriteValue_OpARMMULF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULF (NEGF x) y)
@@ -7814,7 +7814,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULS(v *ssa.Value) bool {
+func rewriteValue_OpARMMULS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8220,7 +8220,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVN(v *ssa.Value) bool {
+func rewriteValue_OpARMMVN(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVN (MOVWconst [c]))
// result: (MOVWconst [^c])
@@ -8310,7 +8310,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftLL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftLL (MOVWconst [c]) [d])
// result: (MOVWconst [^(c<<uint64(d))])
@@ -8326,7 +8326,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftLLreg(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftLLreg x (MOVWconst [c]))
@@ -8348,7 +8348,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftRA(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRA (MOVWconst [c]) [d])
// result: (MOVWconst [int32(c)>>uint64(d)])
@@ -8364,7 +8364,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftRAreg(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftRAreg x (MOVWconst [c]))
@@ -8386,7 +8386,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftRL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRL (MOVWconst [c]) [d])
// result: (MOVWconst [^int32(uint32(c)>>uint64(d))])
@@ -8402,7 +8402,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMMVNshiftRLreg(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftRLreg x (MOVWconst [c]))
@@ -8424,7 +8424,7 @@
}
return false
}
-func rewriteValueARM_OpARMNEGD(v *ssa.Value) bool {
+func rewriteValue_OpARMNEGD(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGD (MULD x y))
// cond: buildcfg.GOARM.Version >= 6
@@ -8444,7 +8444,7 @@
}
return false
}
-func rewriteValueARM_OpARMNEGF(v *ssa.Value) bool {
+func rewriteValue_OpARMNEGF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGF (MULF x y))
// cond: buildcfg.GOARM.Version >= 6
@@ -8464,7 +8464,7 @@
}
return false
}
-func rewriteValueARM_OpARMNMULD(v *ssa.Value) bool {
+func rewriteValue_OpARMNMULD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NMULD (NEGD x) y)
@@ -8484,7 +8484,7 @@
}
return false
}
-func rewriteValueARM_OpARMNMULF(v *ssa.Value) bool {
+func rewriteValue_OpARMNMULF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NMULF (NEGF x) y)
@@ -8504,7 +8504,7 @@
}
return false
}
-func rewriteValueARM_OpARMNotEqual(v *ssa.Value) bool {
+func rewriteValue_OpARMNotEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NotEqual (FlagConstant [fc]))
// result: (MOVWconst [ssa.B2i32(fc.Ne())])
@@ -8530,7 +8530,7 @@
}
return false
}
-func rewriteValueARM_OpARMOR(v *ssa.Value) bool {
+func rewriteValue_OpARMOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (MOVWconst [c]))
@@ -8660,7 +8660,7 @@
}
return false
}
-func rewriteValueARM_OpARMORconst(v *ssa.Value) bool {
+func rewriteValue_OpARMORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -8712,7 +8712,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8798,7 +8798,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8839,7 +8839,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8891,7 +8891,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8932,7 +8932,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8984,7 +8984,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMORshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9025,7 +9025,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSB(v *ssa.Value) bool {
+func rewriteValue_OpARMRSB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RSB (MOVWconst [c]) x)
@@ -9246,7 +9246,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9283,7 +9283,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9324,7 +9324,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9361,7 +9361,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9402,7 +9402,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9439,7 +9439,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBSshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9480,7 +9480,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBconst(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RSBconst [c] (MOVWconst [d]))
// result: (MOVWconst [c-d])
@@ -9538,7 +9538,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9590,7 +9590,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9631,7 +9631,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9683,7 +9683,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9724,7 +9724,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9776,7 +9776,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSBshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9817,7 +9817,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCconst(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RSCconst [c] (ADDconst [d] x) flags)
@@ -9852,7 +9852,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftLL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9892,7 +9892,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftLLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9936,7 +9936,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftRA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9976,7 +9976,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftRAreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10020,7 +10020,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftRL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10060,7 +10060,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMRSCshiftRLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10104,7 +10104,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBC(v *ssa.Value) bool {
+func rewriteValue_OpARMSBC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10312,7 +10312,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCconst(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SBCconst [c] (ADDconst [d] x) flags)
@@ -10347,7 +10347,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftLL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10387,7 +10387,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftLLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10431,7 +10431,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftRA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10471,7 +10471,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftRAreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10515,7 +10515,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftRL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10555,7 +10555,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSBCshiftRLreg(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10599,7 +10599,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLL(v *ssa.Value) bool {
+func rewriteValue_OpARMSLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVWconst [c]))
@@ -10621,7 +10621,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLLconst(v *ssa.Value) bool {
+func rewriteValue_OpARMSLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVWconst [d]))
// result: (MOVWconst [d<<uint64(c)])
@@ -10637,7 +10637,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRA(v *ssa.Value) bool {
+func rewriteValue_OpARMSRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVWconst [c]))
@@ -10659,7 +10659,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAcond(v *ssa.Value) bool {
+func rewriteValue_OpARMSRAcond(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10699,7 +10699,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAconst(v *ssa.Value) bool {
+func rewriteValue_OpARMSRAconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVWconst [d]))
// result: (MOVWconst [d>>uint64(c)])
@@ -10733,7 +10733,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRL(v *ssa.Value) bool {
+func rewriteValue_OpARMSRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVWconst [c]))
@@ -10755,7 +10755,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRLconst(v *ssa.Value) bool {
+func rewriteValue_OpARMSRLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int32(uint32(d)>>uint64(c))])
@@ -10789,7 +10789,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRR(v *ssa.Value) bool {
+func rewriteValue_OpARMSRR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRR x (MOVWconst [c]))
@@ -10807,7 +10807,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUB(v *ssa.Value) bool {
+func rewriteValue_OpARMSUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB (MOVWconst [c]) x)
@@ -11028,7 +11028,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBD(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBD a (MULD x y))
@@ -11067,7 +11067,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBF(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBF a (MULF x y))
@@ -11106,7 +11106,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBS(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBS x (MOVWconst [c]))
@@ -11286,7 +11286,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11323,7 +11323,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11364,7 +11364,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11401,7 +11401,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11442,7 +11442,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11479,7 +11479,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBSshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11520,7 +11520,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBconst(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off2-off1] {sym} ptr)
@@ -11632,7 +11632,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11684,7 +11684,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11725,7 +11725,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11777,7 +11777,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11818,7 +11818,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11870,7 +11870,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMSUBshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11911,7 +11911,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQ(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TEQ x (MOVWconst [c]))
@@ -12031,7 +12031,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQconst(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TEQconst (MOVWconst [x]) [y])
// result: (FlagConstant [ssa.LogicFlags32(x^y)])
@@ -12047,7 +12047,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12084,7 +12084,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12125,7 +12125,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12162,7 +12162,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12203,7 +12203,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12240,7 +12240,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTEQshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12281,7 +12281,7 @@
}
return false
}
-func rewriteValueARM_OpARMTST(v *ssa.Value) bool {
+func rewriteValue_OpARMTST(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TST x (MOVWconst [c]))
@@ -12401,7 +12401,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTconst(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TSTconst (MOVWconst [x]) [y])
// result: (FlagConstant [ssa.LogicFlags32(x&y)])
@@ -12417,7 +12417,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12454,7 +12454,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12495,7 +12495,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12532,7 +12532,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12573,7 +12573,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12610,7 +12610,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMTSTshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12651,7 +12651,7 @@
}
return false
}
-func rewriteValueARM_OpARMXOR(v *ssa.Value) bool {
+func rewriteValue_OpARMXOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVWconst [c]))
@@ -12799,7 +12799,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORconst(v *ssa.Value) bool {
+func rewriteValue_OpARMXORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -12839,7 +12839,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12925,7 +12925,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftLLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12966,7 +12966,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13018,7 +13018,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRAreg(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftRAreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13059,7 +13059,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13111,7 +13111,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRLreg(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftRLreg(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13152,7 +13152,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRR(v *ssa.Value) bool {
+func rewriteValue_OpARMXORshiftRR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13189,7 +13189,7 @@
}
return false
}
-func rewriteValueARM_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVWaddr {sym} base)
@@ -13202,7 +13202,7 @@
return true
}
}
-func rewriteValueARM_OpAvg32u(v *ssa.Value) bool {
+func rewriteValue_OpAvg32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13222,7 +13222,7 @@
return true
}
}
-func rewriteValueARM_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13237,7 +13237,7 @@
return true
}
}
-func rewriteValueARM_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BitLen32 <t> x)
@@ -13253,7 +13253,7 @@
return true
}
}
-func rewriteValueARM_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13268,7 +13268,7 @@
return true
}
}
-func rewriteValueARM_OpBswap32(v *ssa.Value) bool {
+func rewriteValue_OpBswap32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Bswap32 <t> x)
@@ -13313,7 +13313,7 @@
}
return false
}
-func rewriteValueARM_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -13323,7 +13323,7 @@
return true
}
}
-func rewriteValueARM_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -13333,7 +13333,7 @@
return true
}
}
-func rewriteValueARM_OpConst32F(v *ssa.Value) bool {
+func rewriteValue_OpConst32F(v *ssa.Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [float64(val)])
for {
@@ -13343,7 +13343,7 @@
return true
}
}
-func rewriteValueARM_OpConst64F(v *ssa.Value) bool {
+func rewriteValue_OpConst64F(v *ssa.Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [float64(val)])
for {
@@ -13353,7 +13353,7 @@
return true
}
}
-func rewriteValueARM_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -13363,7 +13363,7 @@
return true
}
}
-func rewriteValueARM_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVWconst [ssa.B2i32(t)])
for {
@@ -13373,7 +13373,7 @@
return true
}
}
-func rewriteValueARM_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVWconst [0])
for {
@@ -13382,7 +13382,7 @@
return true
}
}
-func rewriteValueARM_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13434,7 +13434,7 @@
}
return false
}
-func rewriteValueARM_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz32 <t> x)
@@ -13479,7 +13479,7 @@
}
return false
}
-func rewriteValueARM_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13531,7 +13531,7 @@
}
return false
}
-func rewriteValueARM_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13550,7 +13550,7 @@
return true
}
}
-func rewriteValueARM_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13569,7 +13569,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13606,7 +13606,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13624,7 +13624,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13643,7 +13643,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13662,7 +13662,7 @@
return true
}
}
-func rewriteValueARM_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13683,7 +13683,7 @@
return true
}
}
-func rewriteValueARM_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13699,7 +13699,7 @@
return true
}
}
-func rewriteValueARM_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13715,7 +13715,7 @@
return true
}
}
-func rewriteValueARM_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13731,7 +13731,7 @@
return true
}
}
-func rewriteValueARM_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13752,7 +13752,7 @@
return true
}
}
-func rewriteValueARM_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13770,7 +13770,7 @@
return true
}
}
-func rewriteValueARM_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13786,7 +13786,7 @@
return true
}
}
-func rewriteValueARM_OpFMA(v *ssa.Value) bool {
+func rewriteValue_OpFMA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13801,7 +13801,7 @@
return true
}
}
-func rewriteValueARM_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13817,7 +13817,7 @@
return true
}
}
-func rewriteValueARM_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -13832,7 +13832,7 @@
return true
}
}
-func rewriteValueARM_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13848,7 +13848,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13869,7 +13869,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13890,7 +13890,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13906,7 +13906,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13922,7 +13922,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13938,7 +13938,7 @@
return true
}
}
-func rewriteValueARM_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13954,7 +13954,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13975,7 +13975,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13996,7 +13996,7 @@
return true
}
}
-func rewriteValueARM_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14017,7 +14017,7 @@
return true
}
}
-func rewriteValueARM_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14038,7 +14038,7 @@
return true
}
}
-func rewriteValueARM_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14054,7 +14054,7 @@
return true
}
}
-func rewriteValueARM_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14070,7 +14070,7 @@
return true
}
}
-func rewriteValueARM_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14086,7 +14086,7 @@
return true
}
}
-func rewriteValueARM_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14102,7 +14102,7 @@
return true
}
}
-func rewriteValueARM_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14123,7 +14123,7 @@
return true
}
}
-func rewriteValueARM_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14144,7 +14144,7 @@
return true
}
}
-func rewriteValueARM_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -14261,7 +14261,7 @@
}
return false
}
-func rewriteValueARM_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14301,7 +14301,7 @@
}
return false
}
-func rewriteValueARM_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14324,7 +14324,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14344,7 +14344,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -14381,7 +14381,7 @@
}
return false
}
-func rewriteValueARM_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14398,7 +14398,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14421,7 +14421,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14441,7 +14441,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -14478,7 +14478,7 @@
}
return false
}
-func rewriteValueARM_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14495,7 +14495,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14518,7 +14518,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14538,7 +14538,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -14575,7 +14575,7 @@
}
return false
}
-func rewriteValueARM_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14592,7 +14592,7 @@
return true
}
}
-func rewriteValueARM_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14611,7 +14611,7 @@
return true
}
}
-func rewriteValueARM_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14630,7 +14630,7 @@
return true
}
}
-func rewriteValueARM_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14663,7 +14663,7 @@
return true
}
}
-func rewriteValueARM_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14681,7 +14681,7 @@
return true
}
}
-func rewriteValueARM_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14700,7 +14700,7 @@
return true
}
}
-func rewriteValueARM_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14719,7 +14719,7 @@
return true
}
}
-func rewriteValueARM_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14937,7 +14937,7 @@
}
return false
}
-func rewriteValueARM_OpNeg16(v *ssa.Value) bool {
+func rewriteValue_OpNeg16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (RSBconst [0] x)
@@ -14949,7 +14949,7 @@
return true
}
}
-func rewriteValueARM_OpNeg32(v *ssa.Value) bool {
+func rewriteValue_OpNeg32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (RSBconst [0] x)
@@ -14961,7 +14961,7 @@
return true
}
}
-func rewriteValueARM_OpNeg8(v *ssa.Value) bool {
+func rewriteValue_OpNeg8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (RSBconst [0] x)
@@ -14973,7 +14973,7 @@
return true
}
}
-func rewriteValueARM_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14994,7 +14994,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15010,7 +15010,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15026,7 +15026,7 @@
return true
}
}
-func rewriteValueARM_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15042,7 +15042,7 @@
return true
}
}
-func rewriteValueARM_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15063,7 +15063,7 @@
return true
}
}
-func rewriteValueARM_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15079,7 +15079,7 @@
return true
}
}
-func rewriteValueARM_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -15091,7 +15091,7 @@
return true
}
}
-func rewriteValueARM_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVWaddr [int32(off)] ptr)
@@ -15117,7 +15117,7 @@
return true
}
}
-func rewriteValueARM_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15145,7 +15145,7 @@
}
return false
}
-func rewriteValueARM_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15162,7 +15162,7 @@
return true
}
}
-func rewriteValueARM_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15190,7 +15190,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15215,7 +15215,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15238,7 +15238,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15280,7 +15280,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15299,7 +15299,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15321,7 +15321,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15341,7 +15341,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15388,7 +15388,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15407,7 +15407,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15430,7 +15430,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15450,7 +15450,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -15487,7 +15487,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15504,7 +15504,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15524,7 +15524,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15541,7 +15541,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -15580,7 +15580,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15597,7 +15597,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15622,7 +15622,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15645,7 +15645,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15687,7 +15687,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15706,7 +15706,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15728,7 +15728,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15748,7 +15748,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15795,7 +15795,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15814,7 +15814,7 @@
return true
}
}
-func rewriteValueARM_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select0 (CALLudiv x (MOVWconst [1])))
// result: x
@@ -15880,7 +15880,7 @@
}
return false
}
-func rewriteValueARM_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select1 (CALLudiv _ (MOVWconst [1])))
// result: (MOVWconst [0])
@@ -15946,7 +15946,7 @@
}
return false
}
-func rewriteValueARM_OpSignmask(v *ssa.Value) bool {
+func rewriteValue_OpSignmask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SRAconst x [31])
@@ -15958,7 +15958,7 @@
return true
}
}
-func rewriteValueARM_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -15975,7 +15975,7 @@
return true
}
}
-func rewriteValueARM_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16056,7 +16056,7 @@
}
return false
}
-func rewriteValueARM_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16251,7 +16251,7 @@
}
return false
}
-func rewriteValueARM_OpZeromask(v *ssa.Value) bool {
+func rewriteValue_OpZeromask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -16268,7 +16268,7 @@
return true
}
}
-func rewriteBlockARM(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.BlockARMEQ:
// match: (EQ (FlagConstant [fc]) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/arm64_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritearm64/arm64_helpers.go
similarity index 99%
rename from src/cmd/compile/internal/ssacompile/arm64_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm64/arm64_helpers.go
index 99fb3a3..f142250 100644
--- a/src/cmd/compile/internal/ssacompile/arm64_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm64/arm64_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritearm64
import (
"math/bits"
diff --git a/src/cmd/compile/internal/ssacompile/rewriteARM64.go b/src/cmd/compile/internal/ssarewrite/rewritearm64/rewriteARM64.go
similarity index 93%
rename from src/cmd/compile/internal/ssacompile/rewriteARM64.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm64/rewriteARM64.go
index b1990a3..74b106b 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm64/rewriteARM64.go
@@ -1,520 +1,520 @@
// Code generated from _gen/ARM64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritearm64
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueARM64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpARM64ADCSflags:
- return rewriteValueARM64_OpARM64ADCSflags(v)
+ return rewriteValue_OpARM64ADCSflags(v)
case ssaop.OpARM64ADD:
- return rewriteValueARM64_OpARM64ADD(v)
+ return rewriteValue_OpARM64ADD(v)
case ssaop.OpARM64ADDSflags:
- return rewriteValueARM64_OpARM64ADDSflags(v)
+ return rewriteValue_OpARM64ADDSflags(v)
case ssaop.OpARM64ADDconst:
- return rewriteValueARM64_OpARM64ADDconst(v)
+ return rewriteValue_OpARM64ADDconst(v)
case ssaop.OpARM64ADDshiftLL:
- return rewriteValueARM64_OpARM64ADDshiftLL(v)
+ return rewriteValue_OpARM64ADDshiftLL(v)
case ssaop.OpARM64ADDshiftRA:
- return rewriteValueARM64_OpARM64ADDshiftRA(v)
+ return rewriteValue_OpARM64ADDshiftRA(v)
case ssaop.OpARM64ADDshiftRL:
- return rewriteValueARM64_OpARM64ADDshiftRL(v)
+ return rewriteValue_OpARM64ADDshiftRL(v)
case ssaop.OpARM64AND:
- return rewriteValueARM64_OpARM64AND(v)
+ return rewriteValue_OpARM64AND(v)
case ssaop.OpARM64ANDconst:
- return rewriteValueARM64_OpARM64ANDconst(v)
+ return rewriteValue_OpARM64ANDconst(v)
case ssaop.OpARM64ANDshiftLL:
- return rewriteValueARM64_OpARM64ANDshiftLL(v)
+ return rewriteValue_OpARM64ANDshiftLL(v)
case ssaop.OpARM64ANDshiftRA:
- return rewriteValueARM64_OpARM64ANDshiftRA(v)
+ return rewriteValue_OpARM64ANDshiftRA(v)
case ssaop.OpARM64ANDshiftRL:
- return rewriteValueARM64_OpARM64ANDshiftRL(v)
+ return rewriteValue_OpARM64ANDshiftRL(v)
case ssaop.OpARM64ANDshiftRO:
- return rewriteValueARM64_OpARM64ANDshiftRO(v)
+ return rewriteValue_OpARM64ANDshiftRO(v)
case ssaop.OpARM64BIC:
- return rewriteValueARM64_OpARM64BIC(v)
+ return rewriteValue_OpARM64BIC(v)
case ssaop.OpARM64BICshiftLL:
- return rewriteValueARM64_OpARM64BICshiftLL(v)
+ return rewriteValue_OpARM64BICshiftLL(v)
case ssaop.OpARM64BICshiftRA:
- return rewriteValueARM64_OpARM64BICshiftRA(v)
+ return rewriteValue_OpARM64BICshiftRA(v)
case ssaop.OpARM64BICshiftRL:
- return rewriteValueARM64_OpARM64BICshiftRL(v)
+ return rewriteValue_OpARM64BICshiftRL(v)
case ssaop.OpARM64BICshiftRO:
- return rewriteValueARM64_OpARM64BICshiftRO(v)
+ return rewriteValue_OpARM64BICshiftRO(v)
case ssaop.OpARM64CMN:
- return rewriteValueARM64_OpARM64CMN(v)
+ return rewriteValue_OpARM64CMN(v)
case ssaop.OpARM64CMNW:
- return rewriteValueARM64_OpARM64CMNW(v)
+ return rewriteValue_OpARM64CMNW(v)
case ssaop.OpARM64CMNWconst:
- return rewriteValueARM64_OpARM64CMNWconst(v)
+ return rewriteValue_OpARM64CMNWconst(v)
case ssaop.OpARM64CMNconst:
- return rewriteValueARM64_OpARM64CMNconst(v)
+ return rewriteValue_OpARM64CMNconst(v)
case ssaop.OpARM64CMNshiftLL:
- return rewriteValueARM64_OpARM64CMNshiftLL(v)
+ return rewriteValue_OpARM64CMNshiftLL(v)
case ssaop.OpARM64CMNshiftRA:
- return rewriteValueARM64_OpARM64CMNshiftRA(v)
+ return rewriteValue_OpARM64CMNshiftRA(v)
case ssaop.OpARM64CMNshiftRL:
- return rewriteValueARM64_OpARM64CMNshiftRL(v)
+ return rewriteValue_OpARM64CMNshiftRL(v)
case ssaop.OpARM64CMP:
- return rewriteValueARM64_OpARM64CMP(v)
+ return rewriteValue_OpARM64CMP(v)
case ssaop.OpARM64CMPW:
- return rewriteValueARM64_OpARM64CMPW(v)
+ return rewriteValue_OpARM64CMPW(v)
case ssaop.OpARM64CMPWconst:
- return rewriteValueARM64_OpARM64CMPWconst(v)
+ return rewriteValue_OpARM64CMPWconst(v)
case ssaop.OpARM64CMPconst:
- return rewriteValueARM64_OpARM64CMPconst(v)
+ return rewriteValue_OpARM64CMPconst(v)
case ssaop.OpARM64CMPshiftLL:
- return rewriteValueARM64_OpARM64CMPshiftLL(v)
+ return rewriteValue_OpARM64CMPshiftLL(v)
case ssaop.OpARM64CMPshiftRA:
- return rewriteValueARM64_OpARM64CMPshiftRA(v)
+ return rewriteValue_OpARM64CMPshiftRA(v)
case ssaop.OpARM64CMPshiftRL:
- return rewriteValueARM64_OpARM64CMPshiftRL(v)
+ return rewriteValue_OpARM64CMPshiftRL(v)
case ssaop.OpARM64CSEL:
- return rewriteValueARM64_OpARM64CSEL(v)
+ return rewriteValue_OpARM64CSEL(v)
case ssaop.OpARM64CSEL0:
- return rewriteValueARM64_OpARM64CSEL0(v)
+ return rewriteValue_OpARM64CSEL0(v)
case ssaop.OpARM64CSETM:
- return rewriteValueARM64_OpARM64CSETM(v)
+ return rewriteValue_OpARM64CSETM(v)
case ssaop.OpARM64CSINC:
- return rewriteValueARM64_OpARM64CSINC(v)
+ return rewriteValue_OpARM64CSINC(v)
case ssaop.OpARM64CSINV:
- return rewriteValueARM64_OpARM64CSINV(v)
+ return rewriteValue_OpARM64CSINV(v)
case ssaop.OpARM64CSNEG:
- return rewriteValueARM64_OpARM64CSNEG(v)
+ return rewriteValue_OpARM64CSNEG(v)
case ssaop.OpARM64DIV:
- return rewriteValueARM64_OpARM64DIV(v)
+ return rewriteValue_OpARM64DIV(v)
case ssaop.OpARM64DIVW:
- return rewriteValueARM64_OpARM64DIVW(v)
+ return rewriteValue_OpARM64DIVW(v)
case ssaop.OpARM64EON:
- return rewriteValueARM64_OpARM64EON(v)
+ return rewriteValue_OpARM64EON(v)
case ssaop.OpARM64EONshiftLL:
- return rewriteValueARM64_OpARM64EONshiftLL(v)
+ return rewriteValue_OpARM64EONshiftLL(v)
case ssaop.OpARM64EONshiftRA:
- return rewriteValueARM64_OpARM64EONshiftRA(v)
+ return rewriteValue_OpARM64EONshiftRA(v)
case ssaop.OpARM64EONshiftRL:
- return rewriteValueARM64_OpARM64EONshiftRL(v)
+ return rewriteValue_OpARM64EONshiftRL(v)
case ssaop.OpARM64EONshiftRO:
- return rewriteValueARM64_OpARM64EONshiftRO(v)
+ return rewriteValue_OpARM64EONshiftRO(v)
case ssaop.OpARM64Equal:
- return rewriteValueARM64_OpARM64Equal(v)
+ return rewriteValue_OpARM64Equal(v)
case ssaop.OpARM64FADDD:
- return rewriteValueARM64_OpARM64FADDD(v)
+ return rewriteValue_OpARM64FADDD(v)
case ssaop.OpARM64FADDS:
- return rewriteValueARM64_OpARM64FADDS(v)
+ return rewriteValue_OpARM64FADDS(v)
case ssaop.OpARM64FCMPD:
- return rewriteValueARM64_OpARM64FCMPD(v)
+ return rewriteValue_OpARM64FCMPD(v)
case ssaop.OpARM64FCMPS:
- return rewriteValueARM64_OpARM64FCMPS(v)
+ return rewriteValue_OpARM64FCMPS(v)
case ssaop.OpARM64FCSELD:
- return rewriteValueARM64_OpARM64FCSELD(v)
+ return rewriteValue_OpARM64FCSELD(v)
case ssaop.OpARM64FCSELS:
- return rewriteValueARM64_OpARM64FCSELS(v)
+ return rewriteValue_OpARM64FCSELS(v)
case ssaop.OpARM64FCVTDS:
- return rewriteValueARM64_OpARM64FCVTDS(v)
+ return rewriteValue_OpARM64FCVTDS(v)
case ssaop.OpARM64FLDPQ:
- return rewriteValueARM64_OpARM64FLDPQ(v)
+ return rewriteValue_OpARM64FLDPQ(v)
case ssaop.OpARM64FMOVDfpgp:
- return rewriteValueARM64_OpARM64FMOVDfpgp(v)
+ return rewriteValue_OpARM64FMOVDfpgp(v)
case ssaop.OpARM64FMOVDgpfp:
- return rewriteValueARM64_OpARM64FMOVDgpfp(v)
+ return rewriteValue_OpARM64FMOVDgpfp(v)
case ssaop.OpARM64FMOVDload:
- return rewriteValueARM64_OpARM64FMOVDload(v)
+ return rewriteValue_OpARM64FMOVDload(v)
case ssaop.OpARM64FMOVDloadidx:
- return rewriteValueARM64_OpARM64FMOVDloadidx(v)
+ return rewriteValue_OpARM64FMOVDloadidx(v)
case ssaop.OpARM64FMOVDloadidx8:
- return rewriteValueARM64_OpARM64FMOVDloadidx8(v)
+ return rewriteValue_OpARM64FMOVDloadidx8(v)
case ssaop.OpARM64FMOVDstore:
- return rewriteValueARM64_OpARM64FMOVDstore(v)
+ return rewriteValue_OpARM64FMOVDstore(v)
case ssaop.OpARM64FMOVDstoreidx:
- return rewriteValueARM64_OpARM64FMOVDstoreidx(v)
+ return rewriteValue_OpARM64FMOVDstoreidx(v)
case ssaop.OpARM64FMOVDstoreidx8:
- return rewriteValueARM64_OpARM64FMOVDstoreidx8(v)
+ return rewriteValue_OpARM64FMOVDstoreidx8(v)
case ssaop.OpARM64FMOVQload:
- return rewriteValueARM64_OpARM64FMOVQload(v)
+ return rewriteValue_OpARM64FMOVQload(v)
case ssaop.OpARM64FMOVQstore:
- return rewriteValueARM64_OpARM64FMOVQstore(v)
+ return rewriteValue_OpARM64FMOVQstore(v)
case ssaop.OpARM64FMOVSload:
- return rewriteValueARM64_OpARM64FMOVSload(v)
+ return rewriteValue_OpARM64FMOVSload(v)
case ssaop.OpARM64FMOVSloadidx:
- return rewriteValueARM64_OpARM64FMOVSloadidx(v)
+ return rewriteValue_OpARM64FMOVSloadidx(v)
case ssaop.OpARM64FMOVSloadidx4:
- return rewriteValueARM64_OpARM64FMOVSloadidx4(v)
+ return rewriteValue_OpARM64FMOVSloadidx4(v)
case ssaop.OpARM64FMOVSstore:
- return rewriteValueARM64_OpARM64FMOVSstore(v)
+ return rewriteValue_OpARM64FMOVSstore(v)
case ssaop.OpARM64FMOVSstoreidx:
- return rewriteValueARM64_OpARM64FMOVSstoreidx(v)
+ return rewriteValue_OpARM64FMOVSstoreidx(v)
case ssaop.OpARM64FMOVSstoreidx4:
- return rewriteValueARM64_OpARM64FMOVSstoreidx4(v)
+ return rewriteValue_OpARM64FMOVSstoreidx4(v)
case ssaop.OpARM64FMULD:
- return rewriteValueARM64_OpARM64FMULD(v)
+ return rewriteValue_OpARM64FMULD(v)
case ssaop.OpARM64FMULS:
- return rewriteValueARM64_OpARM64FMULS(v)
+ return rewriteValue_OpARM64FMULS(v)
case ssaop.OpARM64FNEGD:
- return rewriteValueARM64_OpARM64FNEGD(v)
+ return rewriteValue_OpARM64FNEGD(v)
case ssaop.OpARM64FNEGS:
- return rewriteValueARM64_OpARM64FNEGS(v)
+ return rewriteValue_OpARM64FNEGS(v)
case ssaop.OpARM64FNMULD:
- return rewriteValueARM64_OpARM64FNMULD(v)
+ return rewriteValue_OpARM64FNMULD(v)
case ssaop.OpARM64FNMULS:
- return rewriteValueARM64_OpARM64FNMULS(v)
+ return rewriteValue_OpARM64FNMULS(v)
case ssaop.OpARM64FSTPQ:
- return rewriteValueARM64_OpARM64FSTPQ(v)
+ return rewriteValue_OpARM64FSTPQ(v)
case ssaop.OpARM64FSUBD:
- return rewriteValueARM64_OpARM64FSUBD(v)
+ return rewriteValue_OpARM64FSUBD(v)
case ssaop.OpARM64FSUBS:
- return rewriteValueARM64_OpARM64FSUBS(v)
+ return rewriteValue_OpARM64FSUBS(v)
case ssaop.OpARM64GreaterEqual:
- return rewriteValueARM64_OpARM64GreaterEqual(v)
+ return rewriteValue_OpARM64GreaterEqual(v)
case ssaop.OpARM64GreaterEqualF:
- return rewriteValueARM64_OpARM64GreaterEqualF(v)
+ return rewriteValue_OpARM64GreaterEqualF(v)
case ssaop.OpARM64GreaterEqualNoov:
- return rewriteValueARM64_OpARM64GreaterEqualNoov(v)
+ return rewriteValue_OpARM64GreaterEqualNoov(v)
case ssaop.OpARM64GreaterEqualU:
- return rewriteValueARM64_OpARM64GreaterEqualU(v)
+ return rewriteValue_OpARM64GreaterEqualU(v)
case ssaop.OpARM64GreaterThan:
- return rewriteValueARM64_OpARM64GreaterThan(v)
+ return rewriteValue_OpARM64GreaterThan(v)
case ssaop.OpARM64GreaterThanF:
- return rewriteValueARM64_OpARM64GreaterThanF(v)
+ return rewriteValue_OpARM64GreaterThanF(v)
case ssaop.OpARM64GreaterThanU:
- return rewriteValueARM64_OpARM64GreaterThanU(v)
+ return rewriteValue_OpARM64GreaterThanU(v)
case ssaop.OpARM64LDP:
- return rewriteValueARM64_OpARM64LDP(v)
+ return rewriteValue_OpARM64LDP(v)
case ssaop.OpARM64LessEqual:
- return rewriteValueARM64_OpARM64LessEqual(v)
+ return rewriteValue_OpARM64LessEqual(v)
case ssaop.OpARM64LessEqualF:
- return rewriteValueARM64_OpARM64LessEqualF(v)
+ return rewriteValue_OpARM64LessEqualF(v)
case ssaop.OpARM64LessEqualU:
- return rewriteValueARM64_OpARM64LessEqualU(v)
+ return rewriteValue_OpARM64LessEqualU(v)
case ssaop.OpARM64LessThan:
- return rewriteValueARM64_OpARM64LessThan(v)
+ return rewriteValue_OpARM64LessThan(v)
case ssaop.OpARM64LessThanF:
- return rewriteValueARM64_OpARM64LessThanF(v)
+ return rewriteValue_OpARM64LessThanF(v)
case ssaop.OpARM64LessThanNoov:
- return rewriteValueARM64_OpARM64LessThanNoov(v)
+ return rewriteValue_OpARM64LessThanNoov(v)
case ssaop.OpARM64LessThanU:
- return rewriteValueARM64_OpARM64LessThanU(v)
+ return rewriteValue_OpARM64LessThanU(v)
case ssaop.OpARM64LoweredPanicBoundsCR:
- return rewriteValueARM64_OpARM64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpARM64LoweredPanicBoundsCR(v)
case ssaop.OpARM64LoweredPanicBoundsRC:
- return rewriteValueARM64_OpARM64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpARM64LoweredPanicBoundsRC(v)
case ssaop.OpARM64LoweredPanicBoundsRR:
- return rewriteValueARM64_OpARM64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpARM64LoweredPanicBoundsRR(v)
case ssaop.OpARM64MADD:
- return rewriteValueARM64_OpARM64MADD(v)
+ return rewriteValue_OpARM64MADD(v)
case ssaop.OpARM64MADDW:
- return rewriteValueARM64_OpARM64MADDW(v)
+ return rewriteValue_OpARM64MADDW(v)
case ssaop.OpARM64MNEG:
- return rewriteValueARM64_OpARM64MNEG(v)
+ return rewriteValue_OpARM64MNEG(v)
case ssaop.OpARM64MNEGW:
- return rewriteValueARM64_OpARM64MNEGW(v)
+ return rewriteValue_OpARM64MNEGW(v)
case ssaop.OpARM64MOD:
- return rewriteValueARM64_OpARM64MOD(v)
+ return rewriteValue_OpARM64MOD(v)
case ssaop.OpARM64MODW:
- return rewriteValueARM64_OpARM64MODW(v)
+ return rewriteValue_OpARM64MODW(v)
case ssaop.OpARM64MOVBUload:
- return rewriteValueARM64_OpARM64MOVBUload(v)
+ return rewriteValue_OpARM64MOVBUload(v)
case ssaop.OpARM64MOVBUloadidx:
- return rewriteValueARM64_OpARM64MOVBUloadidx(v)
+ return rewriteValue_OpARM64MOVBUloadidx(v)
case ssaop.OpARM64MOVBUreg:
- return rewriteValueARM64_OpARM64MOVBUreg(v)
+ return rewriteValue_OpARM64MOVBUreg(v)
case ssaop.OpARM64MOVBload:
- return rewriteValueARM64_OpARM64MOVBload(v)
+ return rewriteValue_OpARM64MOVBload(v)
case ssaop.OpARM64MOVBloadidx:
- return rewriteValueARM64_OpARM64MOVBloadidx(v)
+ return rewriteValue_OpARM64MOVBloadidx(v)
case ssaop.OpARM64MOVBreg:
- return rewriteValueARM64_OpARM64MOVBreg(v)
+ return rewriteValue_OpARM64MOVBreg(v)
case ssaop.OpARM64MOVBstore:
- return rewriteValueARM64_OpARM64MOVBstore(v)
+ return rewriteValue_OpARM64MOVBstore(v)
case ssaop.OpARM64MOVBstoreidx:
- return rewriteValueARM64_OpARM64MOVBstoreidx(v)
+ return rewriteValue_OpARM64MOVBstoreidx(v)
case ssaop.OpARM64MOVDload:
- return rewriteValueARM64_OpARM64MOVDload(v)
+ return rewriteValue_OpARM64MOVDload(v)
case ssaop.OpARM64MOVDloadidx:
- return rewriteValueARM64_OpARM64MOVDloadidx(v)
+ return rewriteValue_OpARM64MOVDloadidx(v)
case ssaop.OpARM64MOVDloadidx8:
- return rewriteValueARM64_OpARM64MOVDloadidx8(v)
+ return rewriteValue_OpARM64MOVDloadidx8(v)
case ssaop.OpARM64MOVDnop:
- return rewriteValueARM64_OpARM64MOVDnop(v)
+ return rewriteValue_OpARM64MOVDnop(v)
case ssaop.OpARM64MOVDreg:
- return rewriteValueARM64_OpARM64MOVDreg(v)
+ return rewriteValue_OpARM64MOVDreg(v)
case ssaop.OpARM64MOVDstore:
- return rewriteValueARM64_OpARM64MOVDstore(v)
+ return rewriteValue_OpARM64MOVDstore(v)
case ssaop.OpARM64MOVDstoreidx:
- return rewriteValueARM64_OpARM64MOVDstoreidx(v)
+ return rewriteValue_OpARM64MOVDstoreidx(v)
case ssaop.OpARM64MOVDstoreidx8:
- return rewriteValueARM64_OpARM64MOVDstoreidx8(v)
+ return rewriteValue_OpARM64MOVDstoreidx8(v)
case ssaop.OpARM64MOVHUload:
- return rewriteValueARM64_OpARM64MOVHUload(v)
+ return rewriteValue_OpARM64MOVHUload(v)
case ssaop.OpARM64MOVHUloadidx:
- return rewriteValueARM64_OpARM64MOVHUloadidx(v)
+ return rewriteValue_OpARM64MOVHUloadidx(v)
case ssaop.OpARM64MOVHUloadidx2:
- return rewriteValueARM64_OpARM64MOVHUloadidx2(v)
+ return rewriteValue_OpARM64MOVHUloadidx2(v)
case ssaop.OpARM64MOVHUreg:
- return rewriteValueARM64_OpARM64MOVHUreg(v)
+ return rewriteValue_OpARM64MOVHUreg(v)
case ssaop.OpARM64MOVHload:
- return rewriteValueARM64_OpARM64MOVHload(v)
+ return rewriteValue_OpARM64MOVHload(v)
case ssaop.OpARM64MOVHloadidx:
- return rewriteValueARM64_OpARM64MOVHloadidx(v)
+ return rewriteValue_OpARM64MOVHloadidx(v)
case ssaop.OpARM64MOVHloadidx2:
- return rewriteValueARM64_OpARM64MOVHloadidx2(v)
+ return rewriteValue_OpARM64MOVHloadidx2(v)
case ssaop.OpARM64MOVHreg:
- return rewriteValueARM64_OpARM64MOVHreg(v)
+ return rewriteValue_OpARM64MOVHreg(v)
case ssaop.OpARM64MOVHstore:
- return rewriteValueARM64_OpARM64MOVHstore(v)
+ return rewriteValue_OpARM64MOVHstore(v)
case ssaop.OpARM64MOVHstoreidx:
- return rewriteValueARM64_OpARM64MOVHstoreidx(v)
+ return rewriteValue_OpARM64MOVHstoreidx(v)
case ssaop.OpARM64MOVHstoreidx2:
- return rewriteValueARM64_OpARM64MOVHstoreidx2(v)
+ return rewriteValue_OpARM64MOVHstoreidx2(v)
case ssaop.OpARM64MOVWUload:
- return rewriteValueARM64_OpARM64MOVWUload(v)
+ return rewriteValue_OpARM64MOVWUload(v)
case ssaop.OpARM64MOVWUloadidx:
- return rewriteValueARM64_OpARM64MOVWUloadidx(v)
+ return rewriteValue_OpARM64MOVWUloadidx(v)
case ssaop.OpARM64MOVWUloadidx4:
- return rewriteValueARM64_OpARM64MOVWUloadidx4(v)
+ return rewriteValue_OpARM64MOVWUloadidx4(v)
case ssaop.OpARM64MOVWUreg:
- return rewriteValueARM64_OpARM64MOVWUreg(v)
+ return rewriteValue_OpARM64MOVWUreg(v)
case ssaop.OpARM64MOVWload:
- return rewriteValueARM64_OpARM64MOVWload(v)
+ return rewriteValue_OpARM64MOVWload(v)
case ssaop.OpARM64MOVWloadidx:
- return rewriteValueARM64_OpARM64MOVWloadidx(v)
+ return rewriteValue_OpARM64MOVWloadidx(v)
case ssaop.OpARM64MOVWloadidx4:
- return rewriteValueARM64_OpARM64MOVWloadidx4(v)
+ return rewriteValue_OpARM64MOVWloadidx4(v)
case ssaop.OpARM64MOVWreg:
- return rewriteValueARM64_OpARM64MOVWreg(v)
+ return rewriteValue_OpARM64MOVWreg(v)
case ssaop.OpARM64MOVWstore:
- return rewriteValueARM64_OpARM64MOVWstore(v)
+ return rewriteValue_OpARM64MOVWstore(v)
case ssaop.OpARM64MOVWstoreidx:
- return rewriteValueARM64_OpARM64MOVWstoreidx(v)
+ return rewriteValue_OpARM64MOVWstoreidx(v)
case ssaop.OpARM64MOVWstoreidx4:
- return rewriteValueARM64_OpARM64MOVWstoreidx4(v)
+ return rewriteValue_OpARM64MOVWstoreidx4(v)
case ssaop.OpARM64MSUB:
- return rewriteValueARM64_OpARM64MSUB(v)
+ return rewriteValue_OpARM64MSUB(v)
case ssaop.OpARM64MSUBW:
- return rewriteValueARM64_OpARM64MSUBW(v)
+ return rewriteValue_OpARM64MSUBW(v)
case ssaop.OpARM64MUL:
- return rewriteValueARM64_OpARM64MUL(v)
+ return rewriteValue_OpARM64MUL(v)
case ssaop.OpARM64MULW:
- return rewriteValueARM64_OpARM64MULW(v)
+ return rewriteValue_OpARM64MULW(v)
case ssaop.OpARM64MVN:
- return rewriteValueARM64_OpARM64MVN(v)
+ return rewriteValue_OpARM64MVN(v)
case ssaop.OpARM64MVNshiftLL:
- return rewriteValueARM64_OpARM64MVNshiftLL(v)
+ return rewriteValue_OpARM64MVNshiftLL(v)
case ssaop.OpARM64MVNshiftRA:
- return rewriteValueARM64_OpARM64MVNshiftRA(v)
+ return rewriteValue_OpARM64MVNshiftRA(v)
case ssaop.OpARM64MVNshiftRL:
- return rewriteValueARM64_OpARM64MVNshiftRL(v)
+ return rewriteValue_OpARM64MVNshiftRL(v)
case ssaop.OpARM64MVNshiftRO:
- return rewriteValueARM64_OpARM64MVNshiftRO(v)
+ return rewriteValue_OpARM64MVNshiftRO(v)
case ssaop.OpARM64NEG:
- return rewriteValueARM64_OpARM64NEG(v)
+ return rewriteValue_OpARM64NEG(v)
case ssaop.OpARM64NEGshiftLL:
- return rewriteValueARM64_OpARM64NEGshiftLL(v)
+ return rewriteValue_OpARM64NEGshiftLL(v)
case ssaop.OpARM64NEGshiftRA:
- return rewriteValueARM64_OpARM64NEGshiftRA(v)
+ return rewriteValue_OpARM64NEGshiftRA(v)
case ssaop.OpARM64NEGshiftRL:
- return rewriteValueARM64_OpARM64NEGshiftRL(v)
+ return rewriteValue_OpARM64NEGshiftRL(v)
case ssaop.OpARM64NotEqual:
- return rewriteValueARM64_OpARM64NotEqual(v)
+ return rewriteValue_OpARM64NotEqual(v)
case ssaop.OpARM64OR:
- return rewriteValueARM64_OpARM64OR(v)
+ return rewriteValue_OpARM64OR(v)
case ssaop.OpARM64ORN:
- return rewriteValueARM64_OpARM64ORN(v)
+ return rewriteValue_OpARM64ORN(v)
case ssaop.OpARM64ORNshiftLL:
- return rewriteValueARM64_OpARM64ORNshiftLL(v)
+ return rewriteValue_OpARM64ORNshiftLL(v)
case ssaop.OpARM64ORNshiftRA:
- return rewriteValueARM64_OpARM64ORNshiftRA(v)
+ return rewriteValue_OpARM64ORNshiftRA(v)
case ssaop.OpARM64ORNshiftRL:
- return rewriteValueARM64_OpARM64ORNshiftRL(v)
+ return rewriteValue_OpARM64ORNshiftRL(v)
case ssaop.OpARM64ORNshiftRO:
- return rewriteValueARM64_OpARM64ORNshiftRO(v)
+ return rewriteValue_OpARM64ORNshiftRO(v)
case ssaop.OpARM64ORconst:
- return rewriteValueARM64_OpARM64ORconst(v)
+ return rewriteValue_OpARM64ORconst(v)
case ssaop.OpARM64ORshiftLL:
- return rewriteValueARM64_OpARM64ORshiftLL(v)
+ return rewriteValue_OpARM64ORshiftLL(v)
case ssaop.OpARM64ORshiftRA:
- return rewriteValueARM64_OpARM64ORshiftRA(v)
+ return rewriteValue_OpARM64ORshiftRA(v)
case ssaop.OpARM64ORshiftRL:
- return rewriteValueARM64_OpARM64ORshiftRL(v)
+ return rewriteValue_OpARM64ORshiftRL(v)
case ssaop.OpARM64ORshiftRO:
- return rewriteValueARM64_OpARM64ORshiftRO(v)
+ return rewriteValue_OpARM64ORshiftRO(v)
case ssaop.OpARM64REV:
- return rewriteValueARM64_OpARM64REV(v)
+ return rewriteValue_OpARM64REV(v)
case ssaop.OpARM64REV16:
- return rewriteValueARM64_OpARM64REV16(v)
+ return rewriteValue_OpARM64REV16(v)
case ssaop.OpARM64REVW:
- return rewriteValueARM64_OpARM64REVW(v)
+ return rewriteValue_OpARM64REVW(v)
case ssaop.OpARM64ROR:
- return rewriteValueARM64_OpARM64ROR(v)
+ return rewriteValue_OpARM64ROR(v)
case ssaop.OpARM64RORW:
- return rewriteValueARM64_OpARM64RORW(v)
+ return rewriteValue_OpARM64RORW(v)
case ssaop.OpARM64SBCSflags:
- return rewriteValueARM64_OpARM64SBCSflags(v)
+ return rewriteValue_OpARM64SBCSflags(v)
case ssaop.OpARM64SBFX:
- return rewriteValueARM64_OpARM64SBFX(v)
+ return rewriteValue_OpARM64SBFX(v)
case ssaop.OpARM64SLL:
- return rewriteValueARM64_OpARM64SLL(v)
+ return rewriteValue_OpARM64SLL(v)
case ssaop.OpARM64SLLconst:
- return rewriteValueARM64_OpARM64SLLconst(v)
+ return rewriteValue_OpARM64SLLconst(v)
case ssaop.OpARM64SRA:
- return rewriteValueARM64_OpARM64SRA(v)
+ return rewriteValue_OpARM64SRA(v)
case ssaop.OpARM64SRAconst:
- return rewriteValueARM64_OpARM64SRAconst(v)
+ return rewriteValue_OpARM64SRAconst(v)
case ssaop.OpARM64SRL:
- return rewriteValueARM64_OpARM64SRL(v)
+ return rewriteValue_OpARM64SRL(v)
case ssaop.OpARM64SRLconst:
- return rewriteValueARM64_OpARM64SRLconst(v)
+ return rewriteValue_OpARM64SRLconst(v)
case ssaop.OpARM64STP:
- return rewriteValueARM64_OpARM64STP(v)
+ return rewriteValue_OpARM64STP(v)
case ssaop.OpARM64SUB:
- return rewriteValueARM64_OpARM64SUB(v)
+ return rewriteValue_OpARM64SUB(v)
case ssaop.OpARM64SUBconst:
- return rewriteValueARM64_OpARM64SUBconst(v)
+ return rewriteValue_OpARM64SUBconst(v)
case ssaop.OpARM64SUBshiftLL:
- return rewriteValueARM64_OpARM64SUBshiftLL(v)
+ return rewriteValue_OpARM64SUBshiftLL(v)
case ssaop.OpARM64SUBshiftRA:
- return rewriteValueARM64_OpARM64SUBshiftRA(v)
+ return rewriteValue_OpARM64SUBshiftRA(v)
case ssaop.OpARM64SUBshiftRL:
- return rewriteValueARM64_OpARM64SUBshiftRL(v)
+ return rewriteValue_OpARM64SUBshiftRL(v)
case ssaop.OpARM64TST:
- return rewriteValueARM64_OpARM64TST(v)
+ return rewriteValue_OpARM64TST(v)
case ssaop.OpARM64TSTW:
- return rewriteValueARM64_OpARM64TSTW(v)
+ return rewriteValue_OpARM64TSTW(v)
case ssaop.OpARM64TSTWconst:
- return rewriteValueARM64_OpARM64TSTWconst(v)
+ return rewriteValue_OpARM64TSTWconst(v)
case ssaop.OpARM64TSTconst:
- return rewriteValueARM64_OpARM64TSTconst(v)
+ return rewriteValue_OpARM64TSTconst(v)
case ssaop.OpARM64TSTshiftLL:
- return rewriteValueARM64_OpARM64TSTshiftLL(v)
+ return rewriteValue_OpARM64TSTshiftLL(v)
case ssaop.OpARM64TSTshiftRA:
- return rewriteValueARM64_OpARM64TSTshiftRA(v)
+ return rewriteValue_OpARM64TSTshiftRA(v)
case ssaop.OpARM64TSTshiftRL:
- return rewriteValueARM64_OpARM64TSTshiftRL(v)
+ return rewriteValue_OpARM64TSTshiftRL(v)
case ssaop.OpARM64TSTshiftRO:
- return rewriteValueARM64_OpARM64TSTshiftRO(v)
+ return rewriteValue_OpARM64TSTshiftRO(v)
case ssaop.OpARM64UBFIZ:
- return rewriteValueARM64_OpARM64UBFIZ(v)
+ return rewriteValue_OpARM64UBFIZ(v)
case ssaop.OpARM64UBFX:
- return rewriteValueARM64_OpARM64UBFX(v)
+ return rewriteValue_OpARM64UBFX(v)
case ssaop.OpARM64UDIV:
- return rewriteValueARM64_OpARM64UDIV(v)
+ return rewriteValue_OpARM64UDIV(v)
case ssaop.OpARM64UDIVW:
- return rewriteValueARM64_OpARM64UDIVW(v)
+ return rewriteValue_OpARM64UDIVW(v)
case ssaop.OpARM64UMOD:
- return rewriteValueARM64_OpARM64UMOD(v)
+ return rewriteValue_OpARM64UMOD(v)
case ssaop.OpARM64UMODW:
- return rewriteValueARM64_OpARM64UMODW(v)
+ return rewriteValue_OpARM64UMODW(v)
case ssaop.OpARM64VBIF16B:
- return rewriteValueARM64_OpARM64VBIF16B(v)
+ return rewriteValue_OpARM64VBIF16B(v)
case ssaop.OpARM64VBIT16B:
- return rewriteValueARM64_OpARM64VBIT16B(v)
+ return rewriteValue_OpARM64VBIT16B(v)
case ssaop.OpARM64VDUPBbcast:
- return rewriteValueARM64_OpARM64VDUPBbcast(v)
+ return rewriteValue_OpARM64VDUPBbcast(v)
case ssaop.OpARM64VFCVTL4S:
- return rewriteValueARM64_OpARM64VFCVTL4S(v)
+ return rewriteValue_OpARM64VFCVTL4S(v)
case ssaop.OpARM64VMOVDins0:
- return rewriteValueARM64_OpARM64VMOVDins0(v)
+ return rewriteValue_OpARM64VMOVDins0(v)
case ssaop.OpARM64VMOVSins0:
- return rewriteValueARM64_OpARM64VMOVSins0(v)
+ return rewriteValue_OpARM64VMOVSins0(v)
case ssaop.OpARM64VPMULL2D:
- return rewriteValueARM64_OpARM64VPMULL2D(v)
+ return rewriteValue_OpARM64VPMULL2D(v)
case ssaop.OpARM64VSHL16B:
- return rewriteValueARM64_OpARM64VSHL16B(v)
+ return rewriteValue_OpARM64VSHL16B(v)
case ssaop.OpARM64VSHL2D:
- return rewriteValueARM64_OpARM64VSHL2D(v)
+ return rewriteValue_OpARM64VSHL2D(v)
case ssaop.OpARM64VSHL4S:
- return rewriteValueARM64_OpARM64VSHL4S(v)
+ return rewriteValue_OpARM64VSHL4S(v)
case ssaop.OpARM64VSHL8H:
- return rewriteValueARM64_OpARM64VSHL8H(v)
+ return rewriteValue_OpARM64VSHL8H(v)
case ssaop.OpARM64VSHRN2D:
- return rewriteValueARM64_OpARM64VSHRN2D(v)
+ return rewriteValue_OpARM64VSHRN2D(v)
case ssaop.OpARM64VSHRN4S:
- return rewriteValueARM64_OpARM64VSHRN4S(v)
+ return rewriteValue_OpARM64VSHRN4S(v)
case ssaop.OpARM64VSHRN8H:
- return rewriteValueARM64_OpARM64VSHRN8H(v)
+ return rewriteValue_OpARM64VSHRN8H(v)
case ssaop.OpARM64VSMULL16B:
- return rewriteValueARM64_OpARM64VSMULL16B(v)
+ return rewriteValue_OpARM64VSMULL16B(v)
case ssaop.OpARM64VSMULL4S:
- return rewriteValueARM64_OpARM64VSMULL4S(v)
+ return rewriteValue_OpARM64VSMULL4S(v)
case ssaop.OpARM64VSMULL8H:
- return rewriteValueARM64_OpARM64VSMULL8H(v)
+ return rewriteValue_OpARM64VSMULL8H(v)
case ssaop.OpARM64VSQSHL16Bconst:
- return rewriteValueARM64_OpARM64VSQSHL16Bconst(v)
+ return rewriteValue_OpARM64VSQSHL16Bconst(v)
case ssaop.OpARM64VSQSHL2Dconst:
- return rewriteValueARM64_OpARM64VSQSHL2Dconst(v)
+ return rewriteValue_OpARM64VSQSHL2Dconst(v)
case ssaop.OpARM64VSQSHL4Sconst:
- return rewriteValueARM64_OpARM64VSQSHL4Sconst(v)
+ return rewriteValue_OpARM64VSQSHL4Sconst(v)
case ssaop.OpARM64VSQSHL8Hconst:
- return rewriteValueARM64_OpARM64VSQSHL8Hconst(v)
+ return rewriteValue_OpARM64VSQSHL8Hconst(v)
case ssaop.OpARM64VSSHLL16B:
- return rewriteValueARM64_OpARM64VSSHLL16B(v)
+ return rewriteValue_OpARM64VSSHLL16B(v)
case ssaop.OpARM64VSSHLL4S:
- return rewriteValueARM64_OpARM64VSSHLL4S(v)
+ return rewriteValue_OpARM64VSSHLL4S(v)
case ssaop.OpARM64VSSHLL8H:
- return rewriteValueARM64_OpARM64VSSHLL8H(v)
+ return rewriteValue_OpARM64VSSHLL8H(v)
case ssaop.OpARM64VSSHR16B:
- return rewriteValueARM64_OpARM64VSSHR16B(v)
+ return rewriteValue_OpARM64VSSHR16B(v)
case ssaop.OpARM64VSSHR2D:
- return rewriteValueARM64_OpARM64VSSHR2D(v)
+ return rewriteValue_OpARM64VSSHR2D(v)
case ssaop.OpARM64VSSHR4S:
- return rewriteValueARM64_OpARM64VSSHR4S(v)
+ return rewriteValue_OpARM64VSSHR4S(v)
case ssaop.OpARM64VSSHR8H:
- return rewriteValueARM64_OpARM64VSSHR8H(v)
+ return rewriteValue_OpARM64VSSHR8H(v)
case ssaop.OpARM64VSXTL16B:
- return rewriteValueARM64_OpARM64VSXTL16B(v)
+ return rewriteValue_OpARM64VSXTL16B(v)
case ssaop.OpARM64VSXTL4S:
- return rewriteValueARM64_OpARM64VSXTL4S(v)
+ return rewriteValue_OpARM64VSXTL4S(v)
case ssaop.OpARM64VSXTL8H:
- return rewriteValueARM64_OpARM64VSXTL8H(v)
+ return rewriteValue_OpARM64VSXTL8H(v)
case ssaop.OpARM64VUMULL16B:
- return rewriteValueARM64_OpARM64VUMULL16B(v)
+ return rewriteValue_OpARM64VUMULL16B(v)
case ssaop.OpARM64VUMULL4S:
- return rewriteValueARM64_OpARM64VUMULL4S(v)
+ return rewriteValue_OpARM64VUMULL4S(v)
case ssaop.OpARM64VUMULL8H:
- return rewriteValueARM64_OpARM64VUMULL8H(v)
+ return rewriteValue_OpARM64VUMULL8H(v)
case ssaop.OpARM64VUQSHL16Bconst:
- return rewriteValueARM64_OpARM64VUQSHL16Bconst(v)
+ return rewriteValue_OpARM64VUQSHL16Bconst(v)
case ssaop.OpARM64VUQSHL2Dconst:
- return rewriteValueARM64_OpARM64VUQSHL2Dconst(v)
+ return rewriteValue_OpARM64VUQSHL2Dconst(v)
case ssaop.OpARM64VUQSHL4Sconst:
- return rewriteValueARM64_OpARM64VUQSHL4Sconst(v)
+ return rewriteValue_OpARM64VUQSHL4Sconst(v)
case ssaop.OpARM64VUQSHL8Hconst:
- return rewriteValueARM64_OpARM64VUQSHL8Hconst(v)
+ return rewriteValue_OpARM64VUQSHL8Hconst(v)
case ssaop.OpARM64VUSHLL16B:
- return rewriteValueARM64_OpARM64VUSHLL16B(v)
+ return rewriteValue_OpARM64VUSHLL16B(v)
case ssaop.OpARM64VUSHLL4S:
- return rewriteValueARM64_OpARM64VUSHLL4S(v)
+ return rewriteValue_OpARM64VUSHLL4S(v)
case ssaop.OpARM64VUSHLL8H:
- return rewriteValueARM64_OpARM64VUSHLL8H(v)
+ return rewriteValue_OpARM64VUSHLL8H(v)
case ssaop.OpARM64VUSHR16B:
- return rewriteValueARM64_OpARM64VUSHR16B(v)
+ return rewriteValue_OpARM64VUSHR16B(v)
case ssaop.OpARM64VUSHR2D:
- return rewriteValueARM64_OpARM64VUSHR2D(v)
+ return rewriteValue_OpARM64VUSHR2D(v)
case ssaop.OpARM64VUSHR4S:
- return rewriteValueARM64_OpARM64VUSHR4S(v)
+ return rewriteValue_OpARM64VUSHR4S(v)
case ssaop.OpARM64VUSHR8H:
- return rewriteValueARM64_OpARM64VUSHR8H(v)
+ return rewriteValue_OpARM64VUSHR8H(v)
case ssaop.OpARM64VUXTL16B:
- return rewriteValueARM64_OpARM64VUXTL16B(v)
+ return rewriteValue_OpARM64VUXTL16B(v)
case ssaop.OpARM64VUXTL4S:
- return rewriteValueARM64_OpARM64VUXTL4S(v)
+ return rewriteValue_OpARM64VUXTL4S(v)
case ssaop.OpARM64VUXTL8H:
- return rewriteValueARM64_OpARM64VUXTL8H(v)
+ return rewriteValue_OpARM64VUXTL8H(v)
case ssaop.OpARM64XOR:
- return rewriteValueARM64_OpARM64XOR(v)
+ return rewriteValue_OpARM64XOR(v)
case ssaop.OpARM64XORconst:
- return rewriteValueARM64_OpARM64XORconst(v)
+ return rewriteValue_OpARM64XORconst(v)
case ssaop.OpARM64XORshiftLL:
- return rewriteValueARM64_OpARM64XORshiftLL(v)
+ return rewriteValue_OpARM64XORshiftLL(v)
case ssaop.OpARM64XORshiftRA:
- return rewriteValueARM64_OpARM64XORshiftRA(v)
+ return rewriteValue_OpARM64XORshiftRA(v)
case ssaop.OpARM64XORshiftRL:
- return rewriteValueARM64_OpARM64XORshiftRL(v)
+ return rewriteValue_OpARM64XORshiftRL(v)
case ssaop.OpARM64XORshiftRO:
- return rewriteValueARM64_OpARM64XORshiftRO(v)
+ return rewriteValue_OpARM64XORshiftRO(v)
case ssaop.OpAbs:
v.Op = ssaop.OpARM64FABSD
return true
@@ -570,7 +570,7 @@
v.Op = ssaop.OpARM64VADD2D
return true
case ssaop.OpAddInt8s:
- return rewriteValueARM64_OpAddInt8s(v)
+ return rewriteValue_OpAddInt8s(v)
case ssaop.OpAddInt8x16:
v.Op = ssaop.OpARM64VADD16B
return true
@@ -614,7 +614,7 @@
v.Op = ssaop.OpARM64VADD16B
return true
case ssaop.OpAddr:
- return rewriteValueARM64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpARM64AND
return true
@@ -799,17 +799,17 @@
v.Op = ssaop.OpARM64VURHADD16B
return true
case ssaop.OpAvg64u:
- return rewriteValueARM64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValueARM64_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueARM64_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueARM64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueARM64_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBitRev16:
- return rewriteValueARM64_OpBitRev16(v)
+ return rewriteValue_OpBitRev16(v)
case ssaop.OpBitRev32:
v.Op = ssaop.OpARM64RBITW
return true
@@ -817,7 +817,7 @@
v.Op = ssaop.OpARM64RBIT
return true
case ssaop.OpBitRev8:
- return rewriteValueARM64_OpBitRev8(v)
+ return rewriteValue_OpBitRev8(v)
case ssaop.OpBswap16:
v.Op = ssaop.OpARM64REV16W
return true
@@ -927,23 +927,23 @@
v.Op = ssaop.OpARM64VEXT16B
return true
case ssaop.OpCondSelect:
- return rewriteValueARM64_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConst16:
- return rewriteValueARM64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueARM64_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
- return rewriteValueARM64_OpConst32F(v)
+ return rewriteValue_OpConst32F(v)
case ssaop.OpConst64:
- return rewriteValueARM64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
- return rewriteValueARM64_OpConst64F(v)
+ return rewriteValue_OpConst64F(v)
case ssaop.OpConst8:
- return rewriteValueARM64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueARM64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueARM64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpConvertLo2ToFloat64Float32x4:
v.Op = ssaop.OpARM64VFCVTL4S
return true
@@ -975,24 +975,24 @@
v.Op = ssaop.OpARM64VFCVTZU2D
return true
case ssaop.OpCount8s:
- return rewriteValueARM64_OpCount8s(v)
+ return rewriteValue_OpCount8s(v)
case ssaop.OpCtz16:
- return rewriteValueARM64_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz32:
- return rewriteValueARM64_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz64:
- return rewriteValueARM64_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz64NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz8:
- return rewriteValueARM64_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz32
return true
@@ -1054,11 +1054,11 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueARM64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueARM64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueARM64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpARM64FDIVS
return true
@@ -1066,7 +1066,7 @@
v.Op = ssaop.OpARM64UDIVW
return true
case ssaop.OpDiv64:
- return rewriteValueARM64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpARM64FDIVD
return true
@@ -1074,9 +1074,9 @@
v.Op = ssaop.OpARM64UDIV
return true
case ssaop.OpDiv8:
- return rewriteValueARM64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueARM64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpDivFloat32x4:
v.Op = ssaop.OpARM64VFDIV4S
return true
@@ -1084,21 +1084,21 @@
v.Op = ssaop.OpARM64VFDIV2D
return true
case ssaop.OpEq16:
- return rewriteValueARM64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueARM64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueARM64_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValueARM64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValueARM64_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueARM64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueARM64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueARM64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpEqualFloat32x4:
v.Op = ssaop.OpARM64VFCMEQ4S
return true
@@ -1148,7 +1148,7 @@
v.Op = ssaop.OpARM64VUXTL16B
return true
case ssaop.OpFMA:
- return rewriteValueARM64_OpFMA(v)
+ return rewriteValue_OpFMA(v)
case ssaop.OpFloor:
v.Op = ssaop.OpARM64FRINTMD
return true
@@ -1243,7 +1243,7 @@
v.Op = ssaop.OpARM64VCMGT2D
return true
case ssaop.OpGreaterInt8s:
- return rewriteValueARM64_OpGreaterInt8s(v)
+ return rewriteValue_OpGreaterInt8s(v)
case ssaop.OpGreaterInt8x16:
v.Op = ssaop.OpARM64VCMGT16B
return true
@@ -1260,9 +1260,9 @@
v.Op = ssaop.OpARM64VCMHI16B
return true
case ssaop.OpHmul32:
- return rewriteValueARM64_OpHmul32(v)
+ return rewriteValue_OpHmul32(v)
case ssaop.OpHmul32u:
- return rewriteValueARM64_OpHmul32u(v)
+ return rewriteValue_OpHmul32u(v)
case ssaop.OpHmul64:
v.Op = ssaop.OpARM64MULH
return true
@@ -1369,11 +1369,11 @@
v.Op = ssaop.OpARM64VTRN216B
return true
case ssaop.OpIsInBounds:
- return rewriteValueARM64_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueARM64_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueARM64_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeadingSignBitsInt16x8:
v.Op = ssaop.OpARM64VCLS8H
return true
@@ -1411,51 +1411,51 @@
v.Op = ssaop.OpARM64VCLZ16B
return true
case ssaop.OpLeq16:
- return rewriteValueARM64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueARM64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueARM64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueARM64_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueARM64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueARM64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValueARM64_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValueARM64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueARM64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueARM64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueARM64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueARM64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueARM64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueARM64_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueARM64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValueARM64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValueARM64_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValueARM64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValueARM64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueARM64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueARM64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLoadMasked8:
- return rewriteValueARM64_OpLoadMasked8(v)
+ return rewriteValue_OpLoadMasked8(v)
case ssaop.OpLocalAddr:
- return rewriteValueARM64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLookupOrZeroInt8x16:
v.Op = ssaop.OpARM64VTBL16B
return true
@@ -1487,13 +1487,13 @@
v.Op = ssaop.OpLsh64x8
return true
case ssaop.OpLsh64x16:
- return rewriteValueARM64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueARM64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueARM64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueARM64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
v.Op = ssaop.OpLsh64x16
return true
@@ -1510,12 +1510,12 @@
v.Op = ssaop.OpARM64FMAXS
return true
case ssaop.OpMax32FSel:
- return rewriteValueARM64_OpMax32FSel(v)
+ return rewriteValue_OpMax32FSel(v)
case ssaop.OpMax64F:
v.Op = ssaop.OpARM64FMAXD
return true
case ssaop.OpMax64FSel:
- return rewriteValueARM64_OpMax64FSel(v)
+ return rewriteValue_OpMax64FSel(v)
case ssaop.OpMaxFloat32x4:
v.Op = ssaop.OpARM64VFMAX4S
return true
@@ -1550,12 +1550,12 @@
v.Op = ssaop.OpARM64FMINS
return true
case ssaop.OpMin32FSel:
- return rewriteValueARM64_OpMin32FSel(v)
+ return rewriteValue_OpMin32FSel(v)
case ssaop.OpMin64F:
v.Op = ssaop.OpARM64FMIND
return true
case ssaop.OpMin64FSel:
- return rewriteValueARM64_OpMin64FSel(v)
+ return rewriteValue_OpMin64FSel(v)
case ssaop.OpMinFloat32x4:
v.Op = ssaop.OpARM64VFMIN4S
return true
@@ -1581,25 +1581,25 @@
v.Op = ssaop.OpARM64VUMIN16B
return true
case ssaop.OpMod16:
- return rewriteValueARM64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueARM64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueARM64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
v.Op = ssaop.OpARM64UMODW
return true
case ssaop.OpMod64:
- return rewriteValueARM64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
v.Op = ssaop.OpARM64UMOD
return true
case ssaop.OpMod8:
- return rewriteValueARM64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueARM64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueARM64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpARM64MULW
return true
@@ -1619,21 +1619,21 @@
v.Op = ssaop.OpARM64MULW
return true
case ssaop.OpMulAddFloat32x4:
- return rewriteValueARM64_OpMulAddFloat32x4(v)
+ return rewriteValue_OpMulAddFloat32x4(v)
case ssaop.OpMulAddFloat64x2:
- return rewriteValueARM64_OpMulAddFloat64x2(v)
+ return rewriteValue_OpMulAddFloat64x2(v)
case ssaop.OpMulAddInt16x8:
- return rewriteValueARM64_OpMulAddInt16x8(v)
+ return rewriteValue_OpMulAddInt16x8(v)
case ssaop.OpMulAddInt32x4:
- return rewriteValueARM64_OpMulAddInt32x4(v)
+ return rewriteValue_OpMulAddInt32x4(v)
case ssaop.OpMulAddInt8x16:
- return rewriteValueARM64_OpMulAddInt8x16(v)
+ return rewriteValue_OpMulAddInt8x16(v)
case ssaop.OpMulAddUint16x8:
- return rewriteValueARM64_OpMulAddUint16x8(v)
+ return rewriteValue_OpMulAddUint16x8(v)
case ssaop.OpMulAddUint32x4:
- return rewriteValueARM64_OpMulAddUint32x4(v)
+ return rewriteValue_OpMulAddUint32x4(v)
case ssaop.OpMulAddUint8x16:
- return rewriteValueARM64_OpMulAddUint8x16(v)
+ return rewriteValue_OpMulAddUint8x16(v)
case ssaop.OpMulFloat32x4:
v.Op = ssaop.OpARM64VFMUL4S
return true
@@ -1713,27 +1713,27 @@
v.Op = ssaop.OpARM64VNEG16B
return true
case ssaop.OpNeq16:
- return rewriteValueARM64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueARM64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueARM64_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValueARM64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValueARM64_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueARM64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpARM64XOR
return true
case ssaop.OpNeqPtr:
- return rewriteValueARM64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpARM64LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueARM64_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpNotInt16x8:
v.Op = ssaop.OpARM64VNOT16B
return true
@@ -1759,7 +1759,7 @@
v.Op = ssaop.OpARM64VNOT16B
return true
case ssaop.OpOffPtr:
- return rewriteValueARM64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOnesCountInt8x16:
v.Op = ssaop.OpARM64VCNT16B
return true
@@ -1833,25 +1833,25 @@
v.Op = ssaop.OpARM64LoweredPanicBoundsRR
return true
case ssaop.OpPopCount16:
- return rewriteValueARM64_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValueARM64_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
- return rewriteValueARM64_OpPopCount64(v)
+ return rewriteValue_OpPopCount64(v)
case ssaop.OpPrefetchCache:
- return rewriteValueARM64_OpPrefetchCache(v)
+ return rewriteValue_OpPrefetchCache(v)
case ssaop.OpPrefetchCacheStreamed:
- return rewriteValueARM64_OpPrefetchCacheStreamed(v)
+ return rewriteValue_OpPrefetchCacheStreamed(v)
case ssaop.OpPubBarrier:
- return rewriteValueARM64_OpPubBarrier(v)
+ return rewriteValue_OpPubBarrier(v)
case ssaop.OpRotateLeft16:
- return rewriteValueARM64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValueARM64_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValueARM64_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValueARM64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound:
v.Op = ssaop.OpARM64FRINTAD
return true
@@ -1871,69 +1871,69 @@
v.Op = ssaop.OpARM64FRINTND
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueARM64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueARM64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueARM64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueARM64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueARM64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueARM64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueARM64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueARM64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueARM64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueARM64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueARM64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueARM64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueARM64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueARM64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueARM64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueARM64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueARM64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueARM64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueARM64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueARM64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueARM64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueARM64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueARM64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueARM64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueARM64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueARM64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueARM64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueARM64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueARM64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueARM64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueARM64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueARM64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSaturateToInt16Int32x4:
v.Op = ssaop.OpARM64VSQXTN4S
return true
@@ -1962,13 +1962,13 @@
v.Op = ssaop.OpARM64VUQXTN8H
return true
case ssaop.OpScalableVectorLen:
- return rewriteValueARM64_OpScalableVectorLen(v)
+ return rewriteValue_OpScalableVectorLen(v)
case ssaop.OpSelect0:
- return rewriteValueARM64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueARM64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSelectN:
- return rewriteValueARM64_OpSelectN(v)
+ return rewriteValue_OpSelectN(v)
case ssaop.OpSetElemFloat32x4:
v.Op = ssaop.OpARM64VMOVSins0
return true
@@ -2000,37 +2000,37 @@
v.Op = ssaop.OpARM64VMOVBins
return true
case ssaop.OpShiftAllLeftInt16x8:
- return rewriteValueARM64_OpShiftAllLeftInt16x8(v)
+ return rewriteValue_OpShiftAllLeftInt16x8(v)
case ssaop.OpShiftAllLeftInt32x4:
- return rewriteValueARM64_OpShiftAllLeftInt32x4(v)
+ return rewriteValue_OpShiftAllLeftInt32x4(v)
case ssaop.OpShiftAllLeftInt64x2:
- return rewriteValueARM64_OpShiftAllLeftInt64x2(v)
+ return rewriteValue_OpShiftAllLeftInt64x2(v)
case ssaop.OpShiftAllLeftInt8x16:
- return rewriteValueARM64_OpShiftAllLeftInt8x16(v)
+ return rewriteValue_OpShiftAllLeftInt8x16(v)
case ssaop.OpShiftAllLeftUint16x8:
- return rewriteValueARM64_OpShiftAllLeftUint16x8(v)
+ return rewriteValue_OpShiftAllLeftUint16x8(v)
case ssaop.OpShiftAllLeftUint32x4:
- return rewriteValueARM64_OpShiftAllLeftUint32x4(v)
+ return rewriteValue_OpShiftAllLeftUint32x4(v)
case ssaop.OpShiftAllLeftUint64x2:
- return rewriteValueARM64_OpShiftAllLeftUint64x2(v)
+ return rewriteValue_OpShiftAllLeftUint64x2(v)
case ssaop.OpShiftAllLeftUint8x16:
- return rewriteValueARM64_OpShiftAllLeftUint8x16(v)
+ return rewriteValue_OpShiftAllLeftUint8x16(v)
case ssaop.OpShiftAllRightInt16x8:
- return rewriteValueARM64_OpShiftAllRightInt16x8(v)
+ return rewriteValue_OpShiftAllRightInt16x8(v)
case ssaop.OpShiftAllRightInt32x4:
- return rewriteValueARM64_OpShiftAllRightInt32x4(v)
+ return rewriteValue_OpShiftAllRightInt32x4(v)
case ssaop.OpShiftAllRightInt64x2:
- return rewriteValueARM64_OpShiftAllRightInt64x2(v)
+ return rewriteValue_OpShiftAllRightInt64x2(v)
case ssaop.OpShiftAllRightInt8x16:
- return rewriteValueARM64_OpShiftAllRightInt8x16(v)
+ return rewriteValue_OpShiftAllRightInt8x16(v)
case ssaop.OpShiftAllRightUint16x8:
- return rewriteValueARM64_OpShiftAllRightUint16x8(v)
+ return rewriteValue_OpShiftAllRightUint16x8(v)
case ssaop.OpShiftAllRightUint32x4:
- return rewriteValueARM64_OpShiftAllRightUint32x4(v)
+ return rewriteValue_OpShiftAllRightUint32x4(v)
case ssaop.OpShiftAllRightUint64x2:
- return rewriteValueARM64_OpShiftAllRightUint64x2(v)
+ return rewriteValue_OpShiftAllRightUint64x2(v)
case ssaop.OpShiftAllRightUint8x16:
- return rewriteValueARM64_OpShiftAllRightUint8x16(v)
+ return rewriteValue_OpShiftAllRightUint8x16(v)
case ssaop.OpShiftInt16x8:
v.Op = ssaop.OpARM64VSSHL8H
return true
@@ -2098,7 +2098,7 @@
v.Op = ssaop.OpARM64MOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValueARM64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpARM64FSQRTD
return true
@@ -2115,9 +2115,9 @@
v.Op = ssaop.OpARM64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValueARM64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpStoreMasked8:
- return rewriteValueARM64_OpStoreMasked8(v)
+ return rewriteValue_OpStoreMasked8(v)
case ssaop.OpSub16:
v.Op = ssaop.OpARM64SUB
return true
@@ -2284,7 +2284,7 @@
v.Op = ssaop.OpARM64VEOR16B
return true
case ssaop.OpZero:
- return rewriteValueARM64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpARM64MOVHUreg
return true
@@ -2304,7 +2304,7 @@
v.Op = ssaop.OpARM64MOVBUreg
return true
case ssaop.OpZeroSIMD:
- return rewriteValueARM64_OpZeroSIMD(v)
+ return rewriteValue_OpZeroSIMD(v)
case ssaop.OpbitSelectInt8x16:
v.Op = ssaop.OpARM64VBIF16B
return true
@@ -2312,25 +2312,25 @@
v.Op = ssaop.OpARM64VBIT16B
return true
case ssaop.Opbroadcast1To16Int8x16:
- return rewriteValueARM64_Opbroadcast1To16Int8x16(v)
+ return rewriteValue_Opbroadcast1To16Int8x16(v)
case ssaop.Opbroadcast1To16Uint8x16:
- return rewriteValueARM64_Opbroadcast1To16Uint8x16(v)
+ return rewriteValue_Opbroadcast1To16Uint8x16(v)
case ssaop.Opbroadcast1To2Float64x2:
- return rewriteValueARM64_Opbroadcast1To2Float64x2(v)
+ return rewriteValue_Opbroadcast1To2Float64x2(v)
case ssaop.Opbroadcast1To2Int64x2:
- return rewriteValueARM64_Opbroadcast1To2Int64x2(v)
+ return rewriteValue_Opbroadcast1To2Int64x2(v)
case ssaop.Opbroadcast1To2Uint64x2:
- return rewriteValueARM64_Opbroadcast1To2Uint64x2(v)
+ return rewriteValue_Opbroadcast1To2Uint64x2(v)
case ssaop.Opbroadcast1To4Float32x4:
- return rewriteValueARM64_Opbroadcast1To4Float32x4(v)
+ return rewriteValue_Opbroadcast1To4Float32x4(v)
case ssaop.Opbroadcast1To4Int32x4:
- return rewriteValueARM64_Opbroadcast1To4Int32x4(v)
+ return rewriteValue_Opbroadcast1To4Int32x4(v)
case ssaop.Opbroadcast1To4Uint32x4:
- return rewriteValueARM64_Opbroadcast1To4Uint32x4(v)
+ return rewriteValue_Opbroadcast1To4Uint32x4(v)
case ssaop.Opbroadcast1To8Int16x8:
- return rewriteValueARM64_Opbroadcast1To8Int16x8(v)
+ return rewriteValue_Opbroadcast1To8Int16x8(v)
case ssaop.Opbroadcast1To8Uint16x8:
- return rewriteValueARM64_Opbroadcast1To8Uint16x8(v)
+ return rewriteValue_Opbroadcast1To8Uint16x8(v)
case ssaop.OpcarrylessMultiplyWidenLoUint64x2:
v.Op = ssaop.OpARM64VPMULL2D
return true
@@ -2397,7 +2397,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADCSflags(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADCSflags(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2446,7 +2446,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADD(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2898,7 +2898,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDSflags(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDSflags(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSflags x (MOVDconst [c]))
@@ -2919,7 +2919,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr))
// cond: ssa.Is32Bit(off1+int64(off2))
@@ -3007,7 +3007,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3168,7 +3168,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3205,7 +3205,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3242,7 +3242,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64AND(v *ssa.Value) bool {
+func rewriteValue_OpARM64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVDconst [c]))
@@ -3376,7 +3376,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVDconst [0])
@@ -3552,7 +3552,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3604,7 +3604,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3656,7 +3656,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3708,7 +3708,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3760,7 +3760,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BIC(v *ssa.Value) bool {
+func rewriteValue_OpARM64BIC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BIC x (MOVDconst [c]))
@@ -3865,7 +3865,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64BICshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftLL x (MOVDconst [c]) [d])
@@ -3899,7 +3899,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64BICshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRA x (MOVDconst [c]) [d])
@@ -3933,7 +3933,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64BICshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRL x (MOVDconst [c]) [d])
@@ -3967,7 +3967,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64BICshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRO x (MOVDconst [c]) [d])
@@ -4001,7 +4001,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMN(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMN x (MOVDconst [c]))
@@ -4088,7 +4088,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNW(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMNW x (MOVDconst [c]))
@@ -4109,7 +4109,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMNWconst [c] y)
// cond: c < 0 && c != -1<<31
@@ -4139,7 +4139,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMNconst [c] y)
// cond: c < 0 && c != -1<<63
@@ -4169,7 +4169,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4206,7 +4206,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4243,7 +4243,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4280,7 +4280,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMP(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4449,7 +4449,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPW(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4498,7 +4498,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst [c] y)
// cond: c < 0 && c != -1<<31
@@ -4552,7 +4552,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPconst [c] y)
// cond: c < 0 && c != -1<<63
@@ -4650,7 +4650,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4689,7 +4689,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4728,7 +4728,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4767,7 +4767,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSEL(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSEL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4996,7 +4996,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSEL0(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSEL0(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CSEL0 [cc] x (InvertFlags cmp))
@@ -5077,7 +5077,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSETM(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSETM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CSETM [cc] (InvertFlags cmp))
// result: (CSETM [arm64Invert(cc)] cmp)
@@ -5120,7 +5120,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSINC(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSINC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5169,7 +5169,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSINV(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSINV(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5217,7 +5217,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSNEG(v *ssa.Value) bool {
+func rewriteValue_OpARM64CSNEG(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5265,7 +5265,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIV(v *ssa.Value) bool {
+func rewriteValue_OpARM64DIV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIV (MOVDconst [c]) (MOVDconst [d]))
@@ -5289,7 +5289,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIVW(v *ssa.Value) bool {
+func rewriteValue_OpARM64DIVW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVW (MOVDconst [c]) (MOVDconst [d]))
@@ -5313,7 +5313,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EON(v *ssa.Value) bool {
+func rewriteValue_OpARM64EON(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EON x (MOVDconst [c]))
@@ -5418,7 +5418,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64EONshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftLL x (MOVDconst [c]) [d])
@@ -5452,7 +5452,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64EONshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftRA x (MOVDconst [c]) [d])
@@ -5486,7 +5486,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64EONshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftRL x (MOVDconst [c]) [d])
@@ -5520,7 +5520,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64EONshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftRO x (MOVDconst [c]) [d])
@@ -5554,7 +5554,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64Equal(v *ssa.Value) bool {
+func rewriteValue_OpARM64Equal(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Equal (CMPconst [0] z:(AND x y)))
@@ -5907,7 +5907,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FADDD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FADDD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDD a (FMULD x y))
@@ -5952,7 +5952,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FADDS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FADDS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS a (FMULS x y))
@@ -5997,7 +5997,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCMPD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FCMPD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6027,7 +6027,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCMPS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FCMPS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6057,7 +6057,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCSELD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FCSELD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6078,7 +6078,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCSELS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FCSELS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6099,7 +6099,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCVTDS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FCVTDS(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FCVTDS (FABSD (FCVTSD x)))
// result: (FABSS x)
@@ -6208,7 +6208,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FLDPQ(v *ssa.Value) bool {
+func rewriteValue_OpARM64FLDPQ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6258,7 +6258,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDfpgp(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDfpgp(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (FMOVDfpgp <t> (Arg [off] {sym}))
@@ -6279,7 +6279,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDgpfp(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDgpfp(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (FMOVDgpfp <t> (Arg [off] {sym}))
@@ -6300,7 +6300,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6405,7 +6405,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6473,7 +6473,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDloadidx8(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDloadidx8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6497,7 +6497,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6607,7 +6607,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6680,7 +6680,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstoreidx8(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVDstoreidx8(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6706,7 +6706,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVQload(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVQload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6756,7 +6756,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVQstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVQstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6809,7 +6809,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSload(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6914,7 +6914,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6982,7 +6982,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSloadidx4(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSloadidx4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7006,7 +7006,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7116,7 +7116,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7189,7 +7189,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstoreidx4(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMOVSstoreidx4(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7215,7 +7215,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMULD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMULD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMULD (FNEGD x) y)
@@ -7235,7 +7235,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMULS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FMULS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMULS (FNEGS x) y)
@@ -7255,7 +7255,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNEGD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FNEGD(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FNEGD (FMULD x y))
// result: (FNMULD x y)
@@ -7283,7 +7283,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNEGS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FNEGS(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FNEGS (FMULS x y))
// result: (FNMULS x y)
@@ -7311,7 +7311,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNMULD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FNMULD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FNMULD (FNEGD x) y)
@@ -7331,7 +7331,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNMULS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FNMULS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FNMULS (FNEGS x) y)
@@ -7351,7 +7351,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FSTPQ(v *ssa.Value) bool {
+func rewriteValue_OpARM64FSTPQ(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7407,7 +7407,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FSUBD(v *ssa.Value) bool {
+func rewriteValue_OpARM64FSUBD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBD a (FMULD x y))
@@ -7480,7 +7480,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FSUBS(v *ssa.Value) bool {
+func rewriteValue_OpARM64FSUBS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS a (FMULS x y))
@@ -7553,7 +7553,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqual(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (GreaterEqual (CMPconst [0] z:(AND x y)))
@@ -7840,7 +7840,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualF(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterEqualF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualF (InvertFlags x))
// result: (LessEqualF x)
@@ -7855,7 +7855,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualNoov(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterEqualNoov(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualNoov (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.GeNoov())])
@@ -7870,7 +7870,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualU(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterEqualU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualU (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.Uge())])
@@ -7896,7 +7896,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThan(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterThan(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (GreaterThan (CMPconst [0] z:(AND x y)))
@@ -8013,7 +8013,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanF(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterThanF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanF (InvertFlags x))
// result: (LessThanF x)
@@ -8028,7 +8028,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanU(v *ssa.Value) bool {
+func rewriteValue_OpARM64GreaterThanU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanU (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.Ugt())])
@@ -8054,7 +8054,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LDP(v *ssa.Value) bool {
+func rewriteValue_OpARM64LDP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8104,7 +8104,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqual(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LessEqual (CMPconst [0] z:(AND x y)))
@@ -8221,7 +8221,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualF(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessEqualF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessEqualF (InvertFlags x))
// result: (GreaterEqualF x)
@@ -8236,7 +8236,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualU(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessEqualU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessEqualU (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.Ule())])
@@ -8262,7 +8262,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThan(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessThan(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LessThan (CMPconst [0] z:(AND x y)))
@@ -8543,7 +8543,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanF(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessThanF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThanF (InvertFlags x))
// result: (GreaterThanF x)
@@ -8558,7 +8558,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanNoov(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessThanNoov(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThanNoov (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.LtNoov())])
@@ -8573,7 +8573,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanU(v *ssa.Value) bool {
+func rewriteValue_OpARM64LessThanU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThanU (FlagConstant [fc]))
// result: (MOVDconst [ssa.B2i(fc.Ult())])
@@ -8599,7 +8599,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpARM64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVDconst [c]) mem)
@@ -8620,7 +8620,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpARM64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVDconst [c]) mem)
@@ -8641,7 +8641,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpARM64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8679,7 +8679,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MADD(v *ssa.Value) bool {
+func rewriteValue_OpARM64MADD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9071,7 +9071,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MADDW(v *ssa.Value) bool {
+func rewriteValue_OpARM64MADDW(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9535,7 +9535,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MNEG(v *ssa.Value) bool {
+func rewriteValue_OpARM64MNEG(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9765,7 +9765,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MNEGW(v *ssa.Value) bool {
+func rewriteValue_OpARM64MNEGW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10023,7 +10023,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOD(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOD (MOVDconst [c]) (MOVDconst [d]))
@@ -10047,7 +10047,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MODW(v *ssa.Value) bool {
+func rewriteValue_OpARM64MODW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MODW (MOVDconst [c]) (MOVDconst [d]))
@@ -10071,7 +10071,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10153,7 +10153,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10195,7 +10195,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg (ANDconst [c] x))
// result: (ANDconst [c&(1<<8-1)] x)
@@ -10300,7 +10300,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10382,7 +10382,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10424,7 +10424,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg (MOVDconst [c]))
// result: (MOVDconst [int64(int8(c))])
@@ -10503,7 +10503,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10678,7 +10678,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10807,7 +10807,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10925,7 +10925,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10993,7 +10993,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDloadidx8(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDloadidx8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11017,7 +11017,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDnop(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDnop (MOVDconst [c]))
// result: (MOVDconst [c])
@@ -11032,7 +11032,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDreg x)
// cond: x.Uses == 1
@@ -11059,7 +11059,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11169,7 +11169,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11242,7 +11242,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstoreidx8(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDstoreidx8(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11268,7 +11268,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11369,7 +11369,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11456,7 +11456,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUloadidx2(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHUloadidx2(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11480,7 +11480,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg (ANDconst [c] x))
// result: (ANDconst [c&(1<<16-1)] x)
@@ -11585,7 +11585,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11686,7 +11686,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11773,7 +11773,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHloadidx2(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHloadidx2(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11797,7 +11797,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg (MOVDconst [c]))
// result: (MOVDconst [int64(int16(c))])
@@ -11876,7 +11876,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12037,7 +12037,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12200,7 +12200,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstoreidx2(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHstoreidx2(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12282,7 +12282,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12400,7 +12400,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12468,7 +12468,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUloadidx4(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWUloadidx4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12492,7 +12492,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg (ANDconst [c] x))
// result: (ANDconst [c&(1<<32-1)] x)
@@ -12597,7 +12597,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12698,7 +12698,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWloadidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12766,7 +12766,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWloadidx4(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWloadidx4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12790,7 +12790,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg (MOVDconst [c]))
// result: (MOVDconst [int64(int32(c))])
@@ -12869,7 +12869,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13013,7 +13013,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13114,7 +13114,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstoreidx4(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWstoreidx4(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13168,7 +13168,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MSUB(v *ssa.Value) bool {
+func rewriteValue_OpARM64MSUB(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13560,7 +13560,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MSUBW(v *ssa.Value) bool {
+func rewriteValue_OpARM64MSUBW(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14024,7 +14024,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MUL(v *ssa.Value) bool {
+func rewriteValue_OpARM64MUL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14156,7 +14156,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MULW(v *ssa.Value) bool {
+func rewriteValue_OpARM64MULW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14251,7 +14251,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVN(v *ssa.Value) bool {
+func rewriteValue_OpARM64MVN(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVN (XOR x y))
// result: (EON x y)
@@ -14350,7 +14350,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64MVNshiftLL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftLL (MOVDconst [c]) [d])
// result: (MOVDconst [^int64(uint64(c)<<uint64(d))])
@@ -14366,7 +14366,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64MVNshiftRA(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRA (MOVDconst [c]) [d])
// result: (MOVDconst [^(c>>uint64(d))])
@@ -14382,7 +14382,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64MVNshiftRL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRL (MOVDconst [c]) [d])
// result: (MOVDconst [^int64(uint64(c)>>uint64(d))])
@@ -14398,7 +14398,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64MVNshiftRO(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRO (MOVDconst [c]) [d])
// result: (MOVDconst [^rotateRight64(c, d)])
@@ -14414,7 +14414,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEG(v *ssa.Value) bool {
+func rewriteValue_OpARM64NEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEG (MUL x y))
// result: (MNEG x y)
@@ -14533,7 +14533,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64NEGshiftLL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftLL (MOVDconst [c]) [d])
// result: (MOVDconst [-int64(uint64(c)<<uint64(d))])
@@ -14549,7 +14549,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64NEGshiftRA(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftRA (MOVDconst [c]) [d])
// result: (MOVDconst [-(c>>uint64(d))])
@@ -14565,7 +14565,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64NEGshiftRL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftRL (MOVDconst [c]) [d])
// result: (MOVDconst [-int64(uint64(c)>>uint64(d))])
@@ -14581,7 +14581,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NotEqual(v *ssa.Value) bool {
+func rewriteValue_OpARM64NotEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (NotEqual (CMPconst [0] z:(AND x y)))
@@ -14934,7 +14934,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64OR(v *ssa.Value) bool {
+func rewriteValue_OpARM64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (MOVDconst [c]))
@@ -15118,7 +15118,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORN(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x (MOVDconst [c]))
@@ -15223,7 +15223,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORNshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftLL x (MOVDconst [c]) [d])
@@ -15257,7 +15257,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORNshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftRA x (MOVDconst [c]) [d])
@@ -15291,7 +15291,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORNshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftRL x (MOVDconst [c]) [d])
@@ -15325,7 +15325,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORNshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftRO x (MOVDconst [c]) [d])
@@ -15359,7 +15359,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -15427,7 +15427,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15648,7 +15648,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15700,7 +15700,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15798,7 +15798,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15850,7 +15850,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64REV(v *ssa.Value) bool {
+func rewriteValue_OpARM64REV(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (REV (REV p))
// result: p
@@ -15864,7 +15864,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64REV16(v *ssa.Value) bool {
+func rewriteValue_OpARM64REV16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (REV16 (MOVWUreg x))
// result: (REV16W x)
@@ -15879,7 +15879,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64REVW(v *ssa.Value) bool {
+func rewriteValue_OpARM64REVW(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (REVW (REVW p))
// result: p
@@ -15893,7 +15893,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ROR(v *ssa.Value) bool {
+func rewriteValue_OpARM64ROR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROR x (MOVDconst [c]))
@@ -15911,7 +15911,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64RORW(v *ssa.Value) bool {
+func rewriteValue_OpARM64RORW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORW x (MOVDconst [c]))
@@ -15929,7 +15929,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SBCSflags(v *ssa.Value) bool {
+func rewriteValue_OpARM64SBCSflags(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15982,7 +15982,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SBFX(v *ssa.Value) bool {
+func rewriteValue_OpARM64SBFX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SBFX [bfc] s:(SLLconst [sc] x))
// cond: s.Uses == 1 && sc <= bfc.Lsb()
@@ -16024,7 +16024,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64SLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVDconst [c]))
@@ -16054,7 +16054,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLLconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVDconst [d]))
// result: (MOVDconst [d<<uint64(c)])
@@ -16201,7 +16201,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64SRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVDconst [c]))
@@ -16231,7 +16231,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRAconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SRAconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVDconst [d]))
// result: (MOVDconst [d>>uint64(c)])
@@ -16370,7 +16370,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64SRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVDconst [c]))
@@ -16400,7 +16400,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRLconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SRLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVDconst [d]))
// result: (MOVDconst [int64(uint64(d)>>uint64(c))])
@@ -16655,7 +16655,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64STP(v *ssa.Value) bool {
+func rewriteValue_OpARM64STP(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -16711,7 +16711,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUB(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17088,7 +17088,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -17142,7 +17142,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUBshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftLL x (MOVDconst [c]) [d])
@@ -17176,7 +17176,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUBshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftRA x (MOVDconst [c]) [d])
@@ -17210,7 +17210,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUBshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftRL x (MOVDconst [c]) [d])
@@ -17244,7 +17244,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TST(v *ssa.Value) bool {
+func rewriteValue_OpARM64TST(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TST x (MOVDconst [c]))
@@ -17353,7 +17353,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTW(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TSTW x (MOVDconst [c]))
@@ -17374,7 +17374,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TSTWconst (MOVDconst [x]) [y])
// result: (FlagConstant [ssa.LogicFlags32(int32(x)&y)])
@@ -17390,7 +17390,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (TSTconst (MOVDconst [x]) [y])
// result: (FlagConstant [ssa.LogicFlags64(x&y)])
@@ -17406,7 +17406,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17443,7 +17443,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17480,7 +17480,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17517,7 +17517,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17554,7 +17554,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UBFIZ(v *ssa.Value) bool {
+func rewriteValue_OpARM64UBFIZ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (UBFIZ [bfc] (SLLconst [sc] x))
// cond: sc < bfc.Width()
@@ -17576,7 +17576,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UBFX(v *ssa.Value) bool {
+func rewriteValue_OpARM64UBFX(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (UBFX [bfc] (ANDconst [c] x))
// cond: isARM64BFMask(0, c, 0) && bfc.Lsb() + bfc.Width() <= arm64BFWidth(c, 0)
@@ -17724,7 +17724,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIV(v *ssa.Value) bool {
+func rewriteValue_OpARM64UDIV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (UDIV x (MOVDconst [1]))
@@ -17775,7 +17775,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIVW(v *ssa.Value) bool {
+func rewriteValue_OpARM64UDIVW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17835,7 +17835,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMOD(v *ssa.Value) bool {
+func rewriteValue_OpARM64UMOD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17903,7 +17903,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMODW(v *ssa.Value) bool {
+func rewriteValue_OpARM64UMODW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17976,7 +17976,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VBIF16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VBIF16B(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17995,7 +17995,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VBIT16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VBIT16B(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18014,7 +18014,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VDUPBbcast(v *ssa.Value) bool {
+func rewriteValue_OpARM64VDUPBbcast(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VDUPBbcast [i] (VMOVBins [j] _ (MOVDconst [c])))
// cond: i == j && c>=-128 && c<=255
@@ -18040,7 +18040,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VFCVTL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VFCVTL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VFCVTL4S (VDUPDextr [1] x))
// result: (VFCVTL2_4S x)
@@ -18055,7 +18055,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VMOVDins0(v *ssa.Value) bool {
+func rewriteValue_OpARM64VMOVDins0(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVDins0 [1] dst (VDUPDextr [0] (VFCVTN2D y)))
@@ -18383,7 +18383,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VMOVSins0(v *ssa.Value) bool {
+func rewriteValue_OpARM64VMOVSins0(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VMOVSins0 [0] (VMOVI16B [0]) y:(VDUPSextr [i] _))
@@ -18401,7 +18401,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VPMULL2D(v *ssa.Value) bool {
+func rewriteValue_OpARM64VPMULL2D(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VPMULL2D (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18424,7 +18424,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHL16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHL16B [a] x)
// cond: a==0
@@ -18440,7 +18440,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHL2D(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHL2D(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHL2D [a] x)
// cond: a==0
@@ -18456,7 +18456,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHL4S [a] x)
// cond: a==0
@@ -18472,7 +18472,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHL8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHL8H [a] x)
// cond: a==0
@@ -18488,7 +18488,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHRN2D(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHRN2D(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHRN2D [0] x)
// result: (VXTN2D x)
@@ -18503,7 +18503,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHRN4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHRN4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHRN4S [0] x)
// result: (VXTN4S x)
@@ -18518,7 +18518,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSHRN8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSHRN8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSHRN8H [0] x)
// result: (VXTN8H x)
@@ -18533,7 +18533,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSMULL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSMULL16B(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSMULL16B (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18556,7 +18556,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSMULL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSMULL4S(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSMULL4S (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18579,7 +18579,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSMULL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSMULL8H(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VSMULL8H (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18602,7 +18602,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSQSHL16Bconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSQSHL16Bconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQSHL16Bconst [a] x)
// cond: a==0
@@ -18618,7 +18618,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSQSHL2Dconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSQSHL2Dconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQSHL2Dconst [a] x)
// cond: a==0
@@ -18634,7 +18634,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSQSHL4Sconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSQSHL4Sconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQSHL4Sconst [a] x)
// cond: a==0
@@ -18650,7 +18650,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSQSHL8Hconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSQSHL8Hconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSQSHL8Hconst [a] x)
// cond: a==0
@@ -18666,7 +18666,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHLL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHLL16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHLL16B [a] (VDUPDextr [1] x))
// result: (VSSHLL2_16B [a] x)
@@ -18683,7 +18683,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHLL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHLL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHLL4S [a] (VDUPDextr [1] x))
// result: (VSSHLL2_4S [a] x)
@@ -18700,7 +18700,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHLL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHLL8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHLL8H [a] (VDUPDextr [1] x))
// result: (VSSHLL2_8H [a] x)
@@ -18717,7 +18717,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHR16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHR16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHR16B [a] x)
// cond: a==0
@@ -18733,7 +18733,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHR2D(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHR2D(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHR2D [a] x)
// cond: a==0
@@ -18749,7 +18749,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHR4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHR4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHR4S [a] x)
// cond: a==0
@@ -18765,7 +18765,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSSHR8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSSHR8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSSHR8H [a] x)
// cond: a==0
@@ -18781,7 +18781,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSXTL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSXTL16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSXTL16B (VDUPDextr [1] x))
// result: (VSXTL2_16B x)
@@ -18796,7 +18796,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSXTL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSXTL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSXTL4S (VDUPDextr [1] x))
// result: (VSXTL2_4S x)
@@ -18811,7 +18811,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VSXTL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VSXTL8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VSXTL8H (VDUPDextr [1] x))
// result: (VSXTL2_8H x)
@@ -18826,7 +18826,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUMULL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUMULL16B(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VUMULL16B (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18849,7 +18849,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUMULL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUMULL4S(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VUMULL4S (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18872,7 +18872,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUMULL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUMULL8H(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (VUMULL8H (VDUPDextr [1] x) (VDUPDextr [1] y))
@@ -18895,7 +18895,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUQSHL16Bconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUQSHL16Bconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUQSHL16Bconst [a] x)
// cond: a==0
@@ -18911,7 +18911,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUQSHL2Dconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUQSHL2Dconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUQSHL2Dconst [a] x)
// cond: a==0
@@ -18927,7 +18927,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUQSHL4Sconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUQSHL4Sconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUQSHL4Sconst [a] x)
// cond: a==0
@@ -18943,7 +18943,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUQSHL8Hconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUQSHL8Hconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUQSHL8Hconst [a] x)
// cond: a==0
@@ -18959,7 +18959,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHLL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHLL16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHLL16B [a] (VDUPDextr [1] x))
// result: (VUSHLL2_16B [a] x)
@@ -18976,7 +18976,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHLL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHLL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHLL4S [a] (VDUPDextr [1] x))
// result: (VUSHLL2_4S [a] x)
@@ -18993,7 +18993,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHLL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHLL8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHLL8H [a] (VDUPDextr [1] x))
// result: (VUSHLL2_8H [a] x)
@@ -19010,7 +19010,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHR16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHR16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHR16B [a] x)
// cond: a==0
@@ -19026,7 +19026,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHR2D(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHR2D(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHR2D [a] x)
// cond: a==0
@@ -19042,7 +19042,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHR4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHR4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHR4S [a] x)
// cond: a==0
@@ -19058,7 +19058,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUSHR8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUSHR8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUSHR8H [a] x)
// cond: a==0
@@ -19074,7 +19074,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUXTL16B(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUXTL16B(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUXTL16B (VDUPDextr [1] x))
// result: (VUXTL2_16B x)
@@ -19089,7 +19089,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUXTL4S(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUXTL4S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUXTL4S (VDUPDextr [1] x))
// result: (VUXTL2_4S x)
@@ -19104,7 +19104,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64VUXTL8H(v *ssa.Value) bool {
+func rewriteValue_OpARM64VUXTL8H(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (VUXTL8H (VDUPDextr [1] x))
// result: (VUXTL2_8H x)
@@ -19119,7 +19119,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XOR(v *ssa.Value) bool {
+func rewriteValue_OpARM64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVDconst [c]))
@@ -19254,7 +19254,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -19305,7 +19305,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftLL(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORshiftLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19481,7 +19481,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRA(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORshiftRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19533,7 +19533,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRL(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORshiftRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19585,7 +19585,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRO(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORshiftRO(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19637,7 +19637,7 @@
}
return false
}
-func rewriteValueARM64_OpAddInt8s(v *ssa.Value) bool {
+func rewriteValue_OpAddInt8s(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19660,7 +19660,7 @@
return true
}
}
-func rewriteValueARM64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} base)
@@ -19673,7 +19673,7 @@
return true
}
}
-func rewriteValueARM64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19693,7 +19693,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19708,7 +19708,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19725,7 +19725,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19742,7 +19742,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19757,7 +19757,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev16(v *ssa.Value) bool {
+func rewriteValue_OpBitRev16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19773,7 +19773,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev8(v *ssa.Value) bool {
+func rewriteValue_OpBitRev8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19789,7 +19789,7 @@
return true
}
}
-func rewriteValueARM64_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19829,7 +19829,7 @@
}
return false
}
-func rewriteValueARM64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -19839,7 +19839,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -19849,7 +19849,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32F(v *ssa.Value) bool {
+func rewriteValue_OpConst32F(v *ssa.Value) bool {
// match: (Const32F [val])
// result: (FMOVSconst [float64(val)])
for {
@@ -19859,7 +19859,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -19869,7 +19869,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64F(v *ssa.Value) bool {
+func rewriteValue_OpConst64F(v *ssa.Value) bool {
// match: (Const64F [val])
// result: (FMOVDconst [float64(val)])
for {
@@ -19879,7 +19879,7 @@
return true
}
}
-func rewriteValueARM64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -19889,7 +19889,7 @@
return true
}
}
-func rewriteValueARM64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVDconst [ssa.B2i(t)])
for {
@@ -19899,7 +19899,7 @@
return true
}
}
-func rewriteValueARM64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -19908,7 +19908,7 @@
return true
}
}
-func rewriteValueARM64_OpCount8s(v *ssa.Value) bool {
+func rewriteValue_OpCount8s(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19926,7 +19926,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19946,7 +19946,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz32 <t> x)
@@ -19961,7 +19961,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz64 <t> x)
@@ -19976,7 +19976,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -19996,7 +19996,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20019,7 +20019,7 @@
}
return false
}
-func rewriteValueARM64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20038,7 +20038,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 [false] x y)
@@ -20055,7 +20055,7 @@
}
return false
}
-func rewriteValueARM64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 [false] x y)
@@ -20072,7 +20072,7 @@
}
return false
}
-func rewriteValueARM64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20091,7 +20091,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20110,7 +20110,7 @@
return true
}
}
-func rewriteValueARM64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20131,7 +20131,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20147,7 +20147,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20163,7 +20163,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20179,7 +20179,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20195,7 +20195,7 @@
return true
}
}
-func rewriteValueARM64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20216,7 +20216,7 @@
return true
}
}
-func rewriteValueARM64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20235,7 +20235,7 @@
return true
}
}
-func rewriteValueARM64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20251,7 +20251,7 @@
return true
}
}
-func rewriteValueARM64_OpFMA(v *ssa.Value) bool {
+func rewriteValue_OpFMA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20266,7 +20266,7 @@
return true
}
}
-func rewriteValueARM64_OpGreaterInt8s(v *ssa.Value) bool {
+func rewriteValue_OpGreaterInt8s(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20292,7 +20292,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32(v *ssa.Value) bool {
+func rewriteValue_OpHmul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20310,7 +20310,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32u(v *ssa.Value) bool {
+func rewriteValue_OpHmul32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20328,7 +20328,7 @@
return true
}
}
-func rewriteValueARM64_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20344,7 +20344,7 @@
return true
}
}
-func rewriteValueARM64_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -20359,7 +20359,7 @@
return true
}
}
-func rewriteValueARM64_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20375,7 +20375,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20396,7 +20396,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20442,7 +20442,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20458,7 +20458,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20474,7 +20474,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20516,7 +20516,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20532,7 +20532,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20548,7 +20548,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20590,7 +20590,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20611,7 +20611,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20657,7 +20657,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20678,7 +20678,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20724,7 +20724,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20740,7 +20740,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20756,7 +20756,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20798,7 +20798,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20814,7 +20814,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20830,7 +20830,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20872,7 +20872,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20893,7 +20893,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20939,7 +20939,7 @@
return true
}
}
-func rewriteValueARM64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -21126,7 +21126,7 @@
}
return false
}
-func rewriteValueARM64_OpLoadMasked8(v *ssa.Value) bool {
+func rewriteValue_OpLoadMasked8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21147,7 +21147,7 @@
}
return false
}
-func rewriteValueARM64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21187,7 +21187,7 @@
}
return false
}
-func rewriteValueARM64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21228,7 +21228,7 @@
}
return false
}
-func rewriteValueARM64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21271,7 +21271,7 @@
}
return false
}
-func rewriteValueARM64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21314,7 +21314,7 @@
}
return false
}
-func rewriteValueARM64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21355,7 +21355,7 @@
}
return false
}
-func rewriteValueARM64_OpMax32FSel(v *ssa.Value) bool {
+func rewriteValue_OpMax32FSel(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21372,7 +21372,7 @@
return true
}
}
-func rewriteValueARM64_OpMax64FSel(v *ssa.Value) bool {
+func rewriteValue_OpMax64FSel(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21389,7 +21389,7 @@
return true
}
}
-func rewriteValueARM64_OpMin32FSel(v *ssa.Value) bool {
+func rewriteValue_OpMin32FSel(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21406,7 +21406,7 @@
return true
}
}
-func rewriteValueARM64_OpMin64FSel(v *ssa.Value) bool {
+func rewriteValue_OpMin64FSel(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21423,7 +21423,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21442,7 +21442,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21461,7 +21461,7 @@
return true
}
}
-func rewriteValueARM64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32 x y)
@@ -21474,7 +21474,7 @@
return true
}
}
-func rewriteValueARM64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -21487,7 +21487,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21506,7 +21506,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21525,7 +21525,7 @@
return true
}
}
-func rewriteValueARM64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22031,7 +22031,7 @@
}
return false
}
-func rewriteValueARM64_OpMulAddFloat32x4(v *ssa.Value) bool {
+func rewriteValue_OpMulAddFloat32x4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22046,7 +22046,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddFloat64x2(v *ssa.Value) bool {
+func rewriteValue_OpMulAddFloat64x2(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22061,7 +22061,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpMulAddInt16x8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22076,7 +22076,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpMulAddInt32x4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22091,7 +22091,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpMulAddInt8x16(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22106,7 +22106,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpMulAddUint16x8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22121,7 +22121,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpMulAddUint32x4(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22136,7 +22136,7 @@
return true
}
}
-func rewriteValueARM64_OpMulAddUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpMulAddUint8x16(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22151,7 +22151,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22172,7 +22172,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22188,7 +22188,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22204,7 +22204,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22220,7 +22220,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22236,7 +22236,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22257,7 +22257,7 @@
return true
}
}
-func rewriteValueARM64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22273,7 +22273,7 @@
return true
}
}
-func rewriteValueARM64_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -22288,7 +22288,7 @@
return true
}
}
-func rewriteValueARM64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// cond: ssa.Is32Bit(off)
@@ -22315,7 +22315,7 @@
return true
}
}
-func rewriteValueARM64_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -22338,7 +22338,7 @@
return true
}
}
-func rewriteValueARM64_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -22361,7 +22361,7 @@
return true
}
}
-func rewriteValueARM64_OpPopCount64(v *ssa.Value) bool {
+func rewriteValue_OpPopCount64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -22382,7 +22382,7 @@
return true
}
}
-func rewriteValueARM64_OpPrefetchCache(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCache(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCache addr mem)
@@ -22396,7 +22396,7 @@
return true
}
}
-func rewriteValueARM64_OpPrefetchCacheStreamed(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCacheStreamed(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCacheStreamed addr mem)
@@ -22410,7 +22410,7 @@
return true
}
}
-func rewriteValueARM64_OpPubBarrier(v *ssa.Value) bool {
+func rewriteValue_OpPubBarrier(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (PubBarrier mem)
// result: (DMB [0xe] mem)
@@ -22422,7 +22422,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22467,7 +22467,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22483,7 +22483,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22499,7 +22499,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22551,7 +22551,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22572,7 +22572,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22593,7 +22593,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22614,7 +22614,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22635,7 +22635,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22656,7 +22656,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22677,7 +22677,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22698,7 +22698,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22719,7 +22719,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22740,7 +22740,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22761,7 +22761,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22782,7 +22782,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22803,7 +22803,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22824,7 +22824,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22845,7 +22845,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22866,7 +22866,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22887,7 +22887,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22928,7 +22928,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22971,7 +22971,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23014,7 +23014,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23055,7 +23055,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23096,7 +23096,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23138,7 +23138,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23180,7 +23180,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23221,7 +23221,7 @@
}
return false
}
-func rewriteValueARM64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23242,7 +23242,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23263,7 +23263,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23284,7 +23284,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23305,7 +23305,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23326,7 +23326,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23347,7 +23347,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23368,7 +23368,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23389,7 +23389,7 @@
return true
}
}
-func rewriteValueARM64_OpScalableVectorLen(v *ssa.Value) bool {
+func rewriteValue_OpScalableVectorLen(v *ssa.Value) bool {
// match: (ScalableVectorLen)
// result: (RDVL [1])
for {
@@ -23398,7 +23398,7 @@
return true
}
}
-func rewriteValueARM64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23469,7 +23469,7 @@
}
return false
}
-func rewriteValueARM64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23551,7 +23551,7 @@
}
return false
}
-func rewriteValueARM64_OpSelectN(v *ssa.Value) bool {
+func rewriteValue_OpSelectN(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -23627,7 +23627,7 @@
}
return false
}
-func rewriteValueARM64_OpShiftAllLeftInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23656,7 +23656,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23685,7 +23685,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23714,7 +23714,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23743,7 +23743,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23772,7 +23772,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23801,7 +23801,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23830,7 +23830,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllLeftUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23859,7 +23859,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23890,7 +23890,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23921,7 +23921,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23952,7 +23952,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23983,7 +23983,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24014,7 +24014,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24045,7 +24045,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24076,7 +24076,7 @@
return true
}
}
-func rewriteValueARM64_OpShiftAllRightUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24107,7 +24107,7 @@
return true
}
}
-func rewriteValueARM64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -24123,7 +24123,7 @@
return true
}
}
-func rewriteValueARM64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -24264,7 +24264,7 @@
}
return false
}
-func rewriteValueARM64_OpStoreMasked8(v *ssa.Value) bool {
+func rewriteValue_OpStoreMasked8(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -24287,7 +24287,7 @@
}
return false
}
-func rewriteValueARM64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24592,7 +24592,7 @@
}
return false
}
-func rewriteValueARM64_OpZeroSIMD(v *ssa.Value) bool {
+func rewriteValue_OpZeroSIMD(v *ssa.Value) bool {
// match: (ZeroSIMD <t>)
// cond: t.Size() == 16
// result: (VMOVI16B [0] <t>)
@@ -24631,7 +24631,7 @@
}
return false
}
-func rewriteValueARM64_Opbroadcast1To16Int8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16Int8x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To16Int8x16 x)
// result: (VDUPBbcast [0] x)
@@ -24643,7 +24643,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To16Uint8x16(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To16Uint8x16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To16Uint8x16 x)
// result: (VDUPBbcast [0] x)
@@ -24655,7 +24655,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To2Float64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2Float64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To2Float64x2 x)
// result: (VDUPDbcast [0] x)
@@ -24667,7 +24667,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To2Int64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2Int64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To2Int64x2 x)
// result: (VDUPDbcast [0] x)
@@ -24679,7 +24679,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To2Uint64x2(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To2Uint64x2(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To2Uint64x2 x)
// result: (VDUPDbcast [0] x)
@@ -24691,7 +24691,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To4Float32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4Float32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To4Float32x4 x)
// result: (VDUPSbcast [0] x)
@@ -24703,7 +24703,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To4Int32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4Int32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To4Int32x4 x)
// result: (VDUPSbcast [0] x)
@@ -24715,7 +24715,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To4Uint32x4(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To4Uint32x4(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To4Uint32x4 x)
// result: (VDUPSbcast [0] x)
@@ -24727,7 +24727,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To8Int16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8Int16x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To8Int16x8 x)
// result: (VDUPHbcast [0] x)
@@ -24739,7 +24739,7 @@
return true
}
}
-func rewriteValueARM64_Opbroadcast1To8Uint16x8(v *ssa.Value) bool {
+func rewriteValue_Opbroadcast1To8Uint16x8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (broadcast1To8Uint16x8 x)
// result: (VDUPHbcast [0] x)
@@ -24751,7 +24751,7 @@
return true
}
}
-func rewriteBlockARM64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockARM64EQ:
diff --git a/src/cmd/compile/internal/ssacompile/arm64latelower_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritearm64latelower/arm64latelower_helpers.go
similarity index 97%
rename from src/cmd/compile/internal/ssacompile/arm64latelower_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm64latelower/arm64latelower_helpers.go
index 933b645..160a862 100644
--- a/src/cmd/compile/internal/ssacompile/arm64latelower_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm64latelower/arm64latelower_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritearm64latelower
// isARM64addcon reports whether x can be encoded as the immediate value in an ADD or SUB instruction.
func isARM64addcon(v int64) bool {
diff --git a/src/cmd/compile/internal/ssacompile/rewriteARM64latelower.go b/src/cmd/compile/internal/ssarewrite/rewritearm64latelower/rewriteARM64latelower.go
similarity index 87%
rename from src/cmd/compile/internal/ssacompile/rewriteARM64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewritearm64latelower/rewriteARM64latelower.go
index 983e7a8..4d53475 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteARM64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritearm64latelower/rewriteARM64latelower.go
@@ -1,60 +1,60 @@
// Code generated from _gen/ARM64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritearm64latelower
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueARM64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpARM64ADDSconstflags:
- return rewriteValueARM64latelower_OpARM64ADDSconstflags(v)
+ return rewriteValue_OpARM64ADDSconstflags(v)
case ssaop.OpARM64ADDconst:
- return rewriteValueARM64latelower_OpARM64ADDconst(v)
+ return rewriteValue_OpARM64ADDconst(v)
case ssaop.OpARM64ANDconst:
- return rewriteValueARM64latelower_OpARM64ANDconst(v)
+ return rewriteValue_OpARM64ANDconst(v)
case ssaop.OpARM64CMNWconst:
- return rewriteValueARM64latelower_OpARM64CMNWconst(v)
+ return rewriteValue_OpARM64CMNWconst(v)
case ssaop.OpARM64CMNconst:
- return rewriteValueARM64latelower_OpARM64CMNconst(v)
+ return rewriteValue_OpARM64CMNconst(v)
case ssaop.OpARM64CMPWconst:
- return rewriteValueARM64latelower_OpARM64CMPWconst(v)
+ return rewriteValue_OpARM64CMPWconst(v)
case ssaop.OpARM64CMPconst:
- return rewriteValueARM64latelower_OpARM64CMPconst(v)
+ return rewriteValue_OpARM64CMPconst(v)
case ssaop.OpARM64MOVBUreg:
- return rewriteValueARM64latelower_OpARM64MOVBUreg(v)
+ return rewriteValue_OpARM64MOVBUreg(v)
case ssaop.OpARM64MOVBreg:
- return rewriteValueARM64latelower_OpARM64MOVBreg(v)
+ return rewriteValue_OpARM64MOVBreg(v)
case ssaop.OpARM64MOVDconst:
- return rewriteValueARM64latelower_OpARM64MOVDconst(v)
+ return rewriteValue_OpARM64MOVDconst(v)
case ssaop.OpARM64MOVDnop:
- return rewriteValueARM64latelower_OpARM64MOVDnop(v)
+ return rewriteValue_OpARM64MOVDnop(v)
case ssaop.OpARM64MOVDreg:
- return rewriteValueARM64latelower_OpARM64MOVDreg(v)
+ return rewriteValue_OpARM64MOVDreg(v)
case ssaop.OpARM64MOVHUreg:
- return rewriteValueARM64latelower_OpARM64MOVHUreg(v)
+ return rewriteValue_OpARM64MOVHUreg(v)
case ssaop.OpARM64MOVHreg:
- return rewriteValueARM64latelower_OpARM64MOVHreg(v)
+ return rewriteValue_OpARM64MOVHreg(v)
case ssaop.OpARM64MOVWUreg:
- return rewriteValueARM64latelower_OpARM64MOVWUreg(v)
+ return rewriteValue_OpARM64MOVWUreg(v)
case ssaop.OpARM64MOVWreg:
- return rewriteValueARM64latelower_OpARM64MOVWreg(v)
+ return rewriteValue_OpARM64MOVWreg(v)
case ssaop.OpARM64ORconst:
- return rewriteValueARM64latelower_OpARM64ORconst(v)
+ return rewriteValue_OpARM64ORconst(v)
case ssaop.OpARM64SLLconst:
- return rewriteValueARM64latelower_OpARM64SLLconst(v)
+ return rewriteValue_OpARM64SLLconst(v)
case ssaop.OpARM64SUBconst:
- return rewriteValueARM64latelower_OpARM64SUBconst(v)
+ return rewriteValue_OpARM64SUBconst(v)
case ssaop.OpARM64TSTWconst:
- return rewriteValueARM64latelower_OpARM64TSTWconst(v)
+ return rewriteValue_OpARM64TSTWconst(v)
case ssaop.OpARM64TSTconst:
- return rewriteValueARM64latelower_OpARM64TSTconst(v)
+ return rewriteValue_OpARM64TSTconst(v)
case ssaop.OpARM64XORconst:
- return rewriteValueARM64latelower_OpARM64XORconst(v)
+ return rewriteValue_OpARM64XORconst(v)
}
return false
}
-func rewriteValueARM64latelower_OpARM64ADDSconstflags(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDSconstflags(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -75,7 +75,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64ADDconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -96,7 +96,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -117,7 +117,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64CMNWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -138,7 +138,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64CMNconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMNconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -159,7 +159,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64CMPWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -180,7 +180,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64CMPconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64CMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -201,7 +201,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(Equal _))
// result: x
@@ -389,7 +389,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -426,7 +426,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVDconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDconst(v *ssa.Value) bool {
// match: (MOVDconst [0])
// result: (ZERO)
for {
@@ -438,7 +438,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVDnop(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDnop (MOVDconst [c]))
// result: (MOVDconst [c])
@@ -453,7 +453,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVDreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVDreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDreg x)
// cond: x.Uses == 1
@@ -469,7 +469,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x)
// cond: ssa.ZeroUpper48Bits(x)
@@ -561,7 +561,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -675,7 +675,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg x)
// cond: ssa.ZeroUpper32Bits(x)
@@ -811,7 +811,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpARM64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -1002,7 +1002,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64ORconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64ORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1023,7 +1023,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64SLLconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [1] x)
// result: (ADD x x)
@@ -1038,7 +1038,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64SUBconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64SUBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1059,7 +1059,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64TSTWconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1080,7 +1080,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64TSTconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64TSTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1101,7 +1101,7 @@
}
return false
}
-func rewriteValueARM64latelower_OpARM64XORconst(v *ssa.Value) bool {
+func rewriteValue_OpARM64XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1122,6 +1122,6 @@
}
return false
}
-func rewriteBlockARM64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/rewritedec.go b/src/cmd/compile/internal/ssarewrite/rewritedec/rewritedec.go
similarity index 91%
rename from src/cmd/compile/internal/ssacompile/rewritedec.go
rename to src/cmd/compile/internal/ssarewrite/rewritedec/rewritedec.go
index 2fe430b..38107dc 100644
--- a/src/cmd/compile/internal/ssacompile/rewritedec.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedec/rewritedec.go
@@ -1,51 +1,51 @@
// Code generated from _gen/dec.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritedec
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuedec(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpArrayMake1:
- return rewriteValuedec_OpArrayMake1(v)
+ return rewriteValue_OpArrayMake1(v)
case ssaop.OpArraySelect:
- return rewriteValuedec_OpArraySelect(v)
+ return rewriteValue_OpArraySelect(v)
case ssaop.OpComplexImag:
- return rewriteValuedec_OpComplexImag(v)
+ return rewriteValue_OpComplexImag(v)
case ssaop.OpComplexReal:
- return rewriteValuedec_OpComplexReal(v)
+ return rewriteValue_OpComplexReal(v)
case ssaop.OpIData:
- return rewriteValuedec_OpIData(v)
+ return rewriteValue_OpIData(v)
case ssaop.OpIMake:
- return rewriteValuedec_OpIMake(v)
+ return rewriteValue_OpIMake(v)
case ssaop.OpITab:
- return rewriteValuedec_OpITab(v)
+ return rewriteValue_OpITab(v)
case ssaop.OpLoad:
- return rewriteValuedec_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpSliceCap:
- return rewriteValuedec_OpSliceCap(v)
+ return rewriteValue_OpSliceCap(v)
case ssaop.OpSliceLen:
- return rewriteValuedec_OpSliceLen(v)
+ return rewriteValue_OpSliceLen(v)
case ssaop.OpSlicePtr:
- return rewriteValuedec_OpSlicePtr(v)
+ return rewriteValue_OpSlicePtr(v)
case ssaop.OpSlicePtrUnchecked:
- return rewriteValuedec_OpSlicePtrUnchecked(v)
+ return rewriteValue_OpSlicePtrUnchecked(v)
case ssaop.OpStore:
- return rewriteValuedec_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpStringLen:
- return rewriteValuedec_OpStringLen(v)
+ return rewriteValue_OpStringLen(v)
case ssaop.OpStringPtr:
- return rewriteValuedec_OpStringPtr(v)
+ return rewriteValue_OpStringPtr(v)
case ssaop.OpStructMake:
- return rewriteValuedec_OpStructMake(v)
+ return rewriteValue_OpStructMake(v)
case ssaop.OpStructSelect:
- return rewriteValuedec_OpStructSelect(v)
+ return rewriteValue_OpStructSelect(v)
}
return false
}
-func rewriteValuedec_OpArrayMake1(v *ssa.Value) bool {
+func rewriteValue_OpArrayMake1(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ArrayMake1 x)
// cond: x.Type.IsPtrShaped()
@@ -60,7 +60,7 @@
}
return false
}
-func rewriteValuedec_OpArraySelect(v *ssa.Value) bool {
+func rewriteValue_OpArraySelect(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ArraySelect [0] x)
@@ -120,7 +120,7 @@
}
return false
}
-func rewriteValuedec_OpComplexImag(v *ssa.Value) bool {
+func rewriteValue_OpComplexImag(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -182,7 +182,7 @@
}
return false
}
-func rewriteValuedec_OpComplexReal(v *ssa.Value) bool {
+func rewriteValue_OpComplexReal(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -238,7 +238,7 @@
}
return false
}
-func rewriteValuedec_OpIData(v *ssa.Value) bool {
+func rewriteValue_OpIData(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -282,7 +282,7 @@
}
return false
}
-func rewriteValuedec_OpIMake(v *ssa.Value) bool {
+func rewriteValue_OpIMake(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IMake _typ (StructMake ___))
@@ -308,7 +308,7 @@
}
return false
}
-func rewriteValuedec_OpITab(v *ssa.Value) bool {
+func rewriteValue_OpITab(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -344,7 +344,7 @@
}
return false
}
-func rewriteValuedec_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -462,7 +462,7 @@
}
return false
}
-func rewriteValuedec_OpSliceCap(v *ssa.Value) bool {
+func rewriteValue_OpSliceCap(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -502,7 +502,7 @@
}
return false
}
-func rewriteValuedec_OpSliceLen(v *ssa.Value) bool {
+func rewriteValue_OpSliceLen(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -542,7 +542,7 @@
}
return false
}
-func rewriteValuedec_OpSlicePtr(v *ssa.Value) bool {
+func rewriteValue_OpSlicePtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SlicePtr (SliceMake ptr _ _ ))
@@ -577,7 +577,7 @@
}
return false
}
-func rewriteValuedec_OpSlicePtrUnchecked(v *ssa.Value) bool {
+func rewriteValue_OpSlicePtrUnchecked(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SlicePtrUnchecked (SliceMake ptr _ _ ))
// result: ptr
@@ -591,7 +591,7 @@
}
return false
}
-func rewriteValuedec_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -758,7 +758,7 @@
}
return false
}
-func rewriteValuedec_OpStringLen(v *ssa.Value) bool {
+func rewriteValue_OpStringLen(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -798,7 +798,7 @@
}
return false
}
-func rewriteValuedec_OpStringPtr(v *ssa.Value) bool {
+func rewriteValue_OpStringPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -834,7 +834,7 @@
}
return false
}
-func rewriteValuedec_OpStructMake(v *ssa.Value) bool {
+func rewriteValue_OpStructMake(v *ssa.Value) bool {
// match: (StructMake x)
// cond: x.Type.IsPtrShaped()
// result: x
@@ -851,7 +851,7 @@
}
return false
}
-func rewriteValuedec_OpStructSelect(v *ssa.Value) bool {
+func rewriteValue_OpStructSelect(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (StructSelect (IData x))
@@ -926,6 +926,6 @@
}
return false
}
-func rewriteBlockdec(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/rewritedec64.go b/src/cmd/compile/internal/ssarewrite/rewritedec64/rewritedec64.go
similarity index 93%
rename from src/cmd/compile/internal/ssacompile/rewritedec64.go
rename to src/cmd/compile/internal/ssarewrite/rewritedec64/rewritedec64.go
index b154722..7b54be0 100644
--- a/src/cmd/compile/internal/ssacompile/rewritedec64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedec64/rewritedec64.go
@@ -1,150 +1,150 @@
// Code generated from _gen/dec64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritedec64
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuedec64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAdd64:
- return rewriteValuedec64_OpAdd64(v)
+ return rewriteValue_OpAdd64(v)
case ssaop.OpAnd64:
- return rewriteValuedec64_OpAnd64(v)
+ return rewriteValue_OpAnd64(v)
case ssaop.OpArg:
- return rewriteValuedec64_OpArg(v)
+ return rewriteValue_OpArg(v)
case ssaop.OpAvg64u:
- return rewriteValuedec64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen64:
- return rewriteValuedec64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBswap64:
- return rewriteValuedec64_OpBswap64(v)
+ return rewriteValue_OpBswap64(v)
case ssaop.OpCom64:
- return rewriteValuedec64_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpConst64:
- return rewriteValuedec64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpCtz64:
- return rewriteValuedec64_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz64NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpEq64:
- return rewriteValuedec64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpHmul64:
- return rewriteValuedec64_OpHmul64(v)
+ return rewriteValue_OpHmul64(v)
case ssaop.OpHmul64u:
- return rewriteValuedec64_OpHmul64u(v)
+ return rewriteValue_OpHmul64u(v)
case ssaop.OpInt64Hi:
- return rewriteValuedec64_OpInt64Hi(v)
+ return rewriteValue_OpInt64Hi(v)
case ssaop.OpInt64Lo:
- return rewriteValuedec64_OpInt64Lo(v)
+ return rewriteValue_OpInt64Lo(v)
case ssaop.OpLast:
- return rewriteValuedec64_OpLast(v)
+ return rewriteValue_OpLast(v)
case ssaop.OpLeq64:
- return rewriteValuedec64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64U:
- return rewriteValuedec64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLess64:
- return rewriteValuedec64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64U:
- return rewriteValuedec64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLoad:
- return rewriteValuedec64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLsh16x64:
- return rewriteValuedec64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh32x64:
- return rewriteValuedec64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh64x16:
- return rewriteValuedec64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValuedec64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValuedec64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValuedec64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x64:
- return rewriteValuedec64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpMul64:
- return rewriteValuedec64_OpMul64(v)
+ return rewriteValue_OpMul64(v)
case ssaop.OpMul64uhilo:
- return rewriteValuedec64_OpMul64uhilo(v)
+ return rewriteValue_OpMul64uhilo(v)
case ssaop.OpNeg64:
- return rewriteValuedec64_OpNeg64(v)
+ return rewriteValue_OpNeg64(v)
case ssaop.OpNeq64:
- return rewriteValuedec64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpOr32:
- return rewriteValuedec64_OpOr32(v)
+ return rewriteValue_OpOr32(v)
case ssaop.OpOr64:
- return rewriteValuedec64_OpOr64(v)
+ return rewriteValue_OpOr64(v)
case ssaop.OpRotateLeft16:
- return rewriteValuedec64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValuedec64_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValuedec64_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValuedec64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRsh16Ux64:
- return rewriteValuedec64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16x64:
- return rewriteValuedec64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh32Ux64:
- return rewriteValuedec64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32x64:
- return rewriteValuedec64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh64Ux16:
- return rewriteValuedec64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValuedec64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValuedec64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValuedec64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValuedec64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValuedec64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValuedec64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValuedec64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux64:
- return rewriteValuedec64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8x64:
- return rewriteValuedec64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpSelect0:
- return rewriteValuedec64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValuedec64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to64:
- return rewriteValuedec64_OpSignExt16to64(v)
+ return rewriteValue_OpSignExt16to64(v)
case ssaop.OpSignExt32to64:
- return rewriteValuedec64_OpSignExt32to64(v)
+ return rewriteValue_OpSignExt32to64(v)
case ssaop.OpSignExt8to64:
- return rewriteValuedec64_OpSignExt8to64(v)
+ return rewriteValue_OpSignExt8to64(v)
case ssaop.OpStore:
- return rewriteValuedec64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub64:
- return rewriteValuedec64_OpSub64(v)
+ return rewriteValue_OpSub64(v)
case ssaop.OpTrunc64to16:
- return rewriteValuedec64_OpTrunc64to16(v)
+ return rewriteValue_OpTrunc64to16(v)
case ssaop.OpTrunc64to32:
- return rewriteValuedec64_OpTrunc64to32(v)
+ return rewriteValue_OpTrunc64to32(v)
case ssaop.OpTrunc64to8:
- return rewriteValuedec64_OpTrunc64to8(v)
+ return rewriteValue_OpTrunc64to8(v)
case ssaop.OpXor64:
- return rewriteValuedec64_OpXor64(v)
+ return rewriteValue_OpXor64(v)
case ssaop.OpZeroExt16to64:
- return rewriteValuedec64_OpZeroExt16to64(v)
+ return rewriteValue_OpZeroExt16to64(v)
case ssaop.OpZeroExt32to64:
- return rewriteValuedec64_OpZeroExt32to64(v)
+ return rewriteValue_OpZeroExt32to64(v)
case ssaop.OpZeroExt8to64:
- return rewriteValuedec64_OpZeroExt8to64(v)
+ return rewriteValue_OpZeroExt8to64(v)
}
return false
}
-func rewriteValuedec64_OpAdd64(v *ssa.Value) bool {
+func rewriteValue_OpAdd64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -179,7 +179,7 @@
return true
}
}
-func rewriteValuedec64_OpAnd64(v *ssa.Value) bool {
+func rewriteValue_OpAnd64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -206,7 +206,7 @@
return true
}
}
-func rewriteValuedec64_OpArg(v *ssa.Value) bool {
+func rewriteValue_OpArg(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -288,7 +288,7 @@
}
return false
}
-func rewriteValuedec64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -310,7 +310,7 @@
return true
}
}
-func rewriteValuedec64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -336,7 +336,7 @@
return true
}
}
-func rewriteValuedec64_OpBswap64(v *ssa.Value) bool {
+func rewriteValue_OpBswap64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -357,7 +357,7 @@
return true
}
}
-func rewriteValuedec64_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -378,7 +378,7 @@
return true
}
}
-func rewriteValuedec64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (Const64 <t> [c])
@@ -417,7 +417,7 @@
}
return false
}
-func rewriteValuedec64_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -445,7 +445,7 @@
return true
}
}
-func rewriteValuedec64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -472,7 +472,7 @@
return true
}
}
-func rewriteValuedec64_OpHmul64(v *ssa.Value) bool {
+func rewriteValue_OpHmul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -511,7 +511,7 @@
return true
}
}
-func rewriteValuedec64_OpHmul64u(v *ssa.Value) bool {
+func rewriteValue_OpHmul64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -528,7 +528,7 @@
return true
}
}
-func rewriteValuedec64_OpInt64Hi(v *ssa.Value) bool {
+func rewriteValue_OpInt64Hi(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Int64Hi (Int64Make hi _))
// result: hi
@@ -542,7 +542,7 @@
}
return false
}
-func rewriteValuedec64_OpInt64Lo(v *ssa.Value) bool {
+func rewriteValue_OpInt64Lo(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Int64Lo (Int64Make _ lo))
// result: lo
@@ -556,7 +556,7 @@
}
return false
}
-func rewriteValuedec64_OpLast(v *ssa.Value) bool {
+func rewriteValue_OpLast(v *ssa.Value) bool {
// match: (Last ___)
// result: v.Args[len(v.Args)-1]
for {
@@ -564,7 +564,7 @@
return true
}
}
-func rewriteValuedec64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -595,7 +595,7 @@
return true
}
}
-func rewriteValuedec64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -626,7 +626,7 @@
return true
}
}
-func rewriteValuedec64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -657,7 +657,7 @@
return true
}
}
-func rewriteValuedec64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -688,7 +688,7 @@
return true
}
}
-func rewriteValuedec64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -780,7 +780,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -861,7 +861,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -942,7 +942,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -979,7 +979,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1016,7 +1016,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1097,7 +1097,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1134,7 +1134,7 @@
return true
}
}
-func rewriteValuedec64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1215,7 +1215,7 @@
return true
}
}
-func rewriteValuedec64_OpMul64(v *ssa.Value) bool {
+func rewriteValue_OpMul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1256,7 +1256,7 @@
return true
}
}
-func rewriteValuedec64_OpMul64uhilo(v *ssa.Value) bool {
+func rewriteValue_OpMul64uhilo(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1341,7 +1341,7 @@
return true
}
}
-func rewriteValuedec64_OpNeg64(v *ssa.Value) bool {
+func rewriteValue_OpNeg64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg64 <t> x)
@@ -1356,7 +1356,7 @@
return true
}
}
-func rewriteValuedec64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1383,7 +1383,7 @@
return true
}
}
-func rewriteValuedec64_OpOr32(v *ssa.Value) bool {
+func rewriteValue_OpOr32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1441,7 +1441,7 @@
}
return false
}
-func rewriteValuedec64_OpOr64(v *ssa.Value) bool {
+func rewriteValue_OpOr64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1468,7 +1468,7 @@
return true
}
}
-func rewriteValuedec64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft16 x (Int64Make hi lo))
@@ -1485,7 +1485,7 @@
}
return false
}
-func rewriteValuedec64_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x (Int64Make hi lo))
@@ -1502,7 +1502,7 @@
}
return false
}
-func rewriteValuedec64_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1973,7 +1973,7 @@
}
return false
}
-func rewriteValuedec64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft8 x (Int64Make hi lo))
@@ -1990,7 +1990,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2071,7 +2071,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2155,7 +2155,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2236,7 +2236,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2318,7 +2318,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2355,7 +2355,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2392,7 +2392,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2473,7 +2473,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2510,7 +2510,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2557,7 +2557,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2602,7 +2602,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2688,7 +2688,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2735,7 +2735,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2816,7 +2816,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2900,7 +2900,7 @@
return true
}
}
-func rewriteValuedec64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select0 (MakeTuple x y))
// result: x
@@ -2914,7 +2914,7 @@
}
return false
}
-func rewriteValuedec64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select1 (MakeTuple x y))
// result: y
@@ -2928,7 +2928,7 @@
}
return false
}
-func rewriteValuedec64_OpSignExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2943,7 +2943,7 @@
return true
}
}
-func rewriteValuedec64_OpSignExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2958,7 +2958,7 @@
return true
}
}
-func rewriteValuedec64_OpSignExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2973,7 +2973,7 @@
return true
}
}
-func rewriteValuedec64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3033,7 +3033,7 @@
}
return false
}
-func rewriteValuedec64_OpSub64(v *ssa.Value) bool {
+func rewriteValue_OpSub64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3068,7 +3068,7 @@
return true
}
}
-func rewriteValuedec64_OpTrunc64to16(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3094,7 +3094,7 @@
return true
}
}
-func rewriteValuedec64_OpTrunc64to32(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 (Int64Make _ lo))
// result: lo
@@ -3115,7 +3115,7 @@
return true
}
}
-func rewriteValuedec64_OpTrunc64to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3141,7 +3141,7 @@
return true
}
}
-func rewriteValuedec64_OpXor64(v *ssa.Value) bool {
+func rewriteValue_OpXor64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3168,7 +3168,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3183,7 +3183,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3198,7 +3198,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3213,6 +3213,6 @@
return true
}
}
-func rewriteBlockdec64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/divisible_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritedivisible/divisible_helpers.go
similarity index 97%
rename from src/cmd/compile/internal/ssacompile/divisible_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritedivisible/divisible_helpers.go
index 2d96a9a..c821ff0 100644
--- a/src/cmd/compile/internal/ssacompile/divisible_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedivisible/divisible_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritedivisible
import "cmd/compile/internal/ssa"
diff --git a/src/cmd/compile/internal/ssacompile/rewritedivisible.go b/src/cmd/compile/internal/ssarewrite/rewritedivisible/rewritedivisible.go
similarity index 97%
rename from src/cmd/compile/internal/ssacompile/rewritedivisible.go
rename to src/cmd/compile/internal/ssarewrite/rewritedivisible/rewritedivisible.go
index 7e614e0..98992bf 100644
--- a/src/cmd/compile/internal/ssacompile/rewritedivisible.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedivisible/rewritedivisible.go
@@ -1,32 +1,32 @@
// Code generated from _gen/divisible.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritedivisible
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuedivisible(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpEq16:
- return rewriteValuedivisible_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValuedivisible_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq64:
- return rewriteValuedivisible_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq8:
- return rewriteValuedivisible_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpNeq16:
- return rewriteValuedivisible_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValuedivisible_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq64:
- return rewriteValuedivisible_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq8:
- return rewriteValuedivisible_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
}
return false
}
-func rewriteValuedivisible_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -214,7 +214,7 @@
}
return false
}
-func rewriteValuedivisible_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -402,7 +402,7 @@
}
return false
}
-func rewriteValuedivisible_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -590,7 +590,7 @@
}
return false
}
-func rewriteValuedivisible_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -778,7 +778,7 @@
}
return false
}
-func rewriteValuedivisible_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -966,7 +966,7 @@
}
return false
}
-func rewriteValuedivisible_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1154,7 +1154,7 @@
}
return false
}
-func rewriteValuedivisible_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1342,7 +1342,7 @@
}
return false
}
-func rewriteValuedivisible_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1530,6 +1530,6 @@
}
return false
}
-func rewriteBlockdivisible(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/divmod_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritedivmod/divmod_helpers.go
similarity index 98%
rename from src/cmd/compile/internal/ssacompile/divmod_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritedivmod/divmod_helpers.go
index 1931c74..bbe52a0 100644
--- a/src/cmd/compile/internal/ssacompile/divmod_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedivmod/divmod_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritedivmod
import "cmd/compile/internal/ssa"
diff --git a/src/cmd/compile/internal/ssacompile/rewritedivmod.go b/src/cmd/compile/internal/ssarewrite/rewritedivmod/rewritedivmod.go
similarity index 97%
rename from src/cmd/compile/internal/ssacompile/rewritedivmod.go
rename to src/cmd/compile/internal/ssarewrite/rewritedivmod/rewritedivmod.go
index 908b4f0..76808a4 100644
--- a/src/cmd/compile/internal/ssacompile/rewritedivmod.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritedivmod/rewritedivmod.go
@@ -1,32 +1,32 @@
// Code generated from _gen/divmod.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritedivmod
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuedivmod(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpDiv16:
- return rewriteValuedivmod_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValuedivmod_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValuedivmod_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32u:
- return rewriteValuedivmod_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValuedivmod_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64u:
- return rewriteValuedivmod_OpDiv64u(v)
+ return rewriteValue_OpDiv64u(v)
case ssaop.OpDiv8:
- return rewriteValuedivmod_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValuedivmod_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
}
return false
}
-func rewriteValuedivmod_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -94,7 +94,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -250,7 +250,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -381,7 +381,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -635,7 +635,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -733,7 +733,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv64u(v *ssa.Value) bool {
+func rewriteValue_OpDiv64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -842,7 +842,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -910,7 +910,7 @@
}
return false
}
-func rewriteValuedivmod_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -945,6 +945,6 @@
}
return false
}
-func rewriteBlockdivmod(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/generic_helpers.go b/src/cmd/compile/internal/ssarewrite/rewritegeneric/generic_helpers.go
similarity index 96%
rename from src/cmd/compile/internal/ssacompile/generic_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewritegeneric/generic_helpers.go
index 822b8a1..1c74645 100644
--- a/src/cmd/compile/internal/ssacompile/generic_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritegeneric/generic_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewritegeneric
import (
"fmt"
@@ -146,22 +146,6 @@
}
}
-func isConstZero(v *ssa.Value) bool {
- switch v.Op {
- case ssaop.OpConstNil:
- return true
- case ssaop.OpConst64, ssaop.OpConst32, ssaop.OpConst16, ssaop.OpConst8, ssaop.OpConstBool, ssaop.OpConst32F, ssaop.OpConst64F:
- return v.AuxInt == 0
- case ssaop.OpStringMake, ssaop.OpIMake, ssaop.OpComplexMake:
- return isConstZero(v.Args[0]) && isConstZero(v.Args[1])
- case ssaop.OpSliceMake:
- return isConstZero(v.Args[0]) && isConstZero(v.Args[1]) && isConstZero(v.Args[2])
- case ssaop.OpStringPtr, ssaop.OpStringLen, ssaop.OpSlicePtr, ssaop.OpSliceLen, ssaop.OpSliceCap, ssaop.OpITab, ssaop.OpIData, ssaop.OpComplexReal, ssaop.OpComplexImag:
- return isConstZero(v.Args[0])
- }
- return false
-}
-
func isDictArgSym(sym ssa.Sym) bool {
return sym.(*ir.Name).Sym().Name == typecheck.LocalDictName
}
diff --git a/src/cmd/compile/internal/ssacompile/rewritegeneric.go b/src/cmd/compile/internal/ssarewrite/rewritegeneric/rewritegeneric.go
similarity index 97%
rename from src/cmd/compile/internal/ssacompile/rewritegeneric.go
rename to src/cmd/compile/internal/ssarewrite/rewritegeneric/rewritegeneric.go
index 5f196816..3f37b58 100644
--- a/src/cmd/compile/internal/ssacompile/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritegeneric/rewritegeneric.go
@@ -1,6 +1,6 @@
// Code generated from _gen/generic.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritegeneric
import "math"
import "math/bits"
@@ -11,510 +11,510 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuegeneric(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAdd16:
- return rewriteValuegeneric_OpAdd16(v)
+ return rewriteValue_OpAdd16(v)
case ssaop.OpAdd32:
- return rewriteValuegeneric_OpAdd32(v)
+ return rewriteValue_OpAdd32(v)
case ssaop.OpAdd32F:
- return rewriteValuegeneric_OpAdd32F(v)
+ return rewriteValue_OpAdd32F(v)
case ssaop.OpAdd64:
- return rewriteValuegeneric_OpAdd64(v)
+ return rewriteValue_OpAdd64(v)
case ssaop.OpAdd64F:
- return rewriteValuegeneric_OpAdd64F(v)
+ return rewriteValue_OpAdd64F(v)
case ssaop.OpAdd64carry:
- return rewriteValuegeneric_OpAdd64carry(v)
+ return rewriteValue_OpAdd64carry(v)
case ssaop.OpAdd8:
- return rewriteValuegeneric_OpAdd8(v)
+ return rewriteValue_OpAdd8(v)
case ssaop.OpAddPtr:
- return rewriteValuegeneric_OpAddPtr(v)
+ return rewriteValue_OpAddPtr(v)
case ssaop.OpAnd16:
- return rewriteValuegeneric_OpAnd16(v)
+ return rewriteValue_OpAnd16(v)
case ssaop.OpAnd32:
- return rewriteValuegeneric_OpAnd32(v)
+ return rewriteValue_OpAnd32(v)
case ssaop.OpAnd64:
- return rewriteValuegeneric_OpAnd64(v)
+ return rewriteValue_OpAnd64(v)
case ssaop.OpAnd8:
- return rewriteValuegeneric_OpAnd8(v)
+ return rewriteValue_OpAnd8(v)
case ssaop.OpAndB:
- return rewriteValuegeneric_OpAndB(v)
+ return rewriteValue_OpAndB(v)
case ssaop.OpArraySelect:
- return rewriteValuegeneric_OpArraySelect(v)
+ return rewriteValue_OpArraySelect(v)
case ssaop.OpBitLen16:
- return rewriteValuegeneric_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValuegeneric_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValuegeneric_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValuegeneric_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBitRev16:
- return rewriteValuegeneric_OpBitRev16(v)
+ return rewriteValue_OpBitRev16(v)
case ssaop.OpBitRev32:
- return rewriteValuegeneric_OpBitRev32(v)
+ return rewriteValue_OpBitRev32(v)
case ssaop.OpBitRev64:
- return rewriteValuegeneric_OpBitRev64(v)
+ return rewriteValue_OpBitRev64(v)
case ssaop.OpBitRev8:
- return rewriteValuegeneric_OpBitRev8(v)
+ return rewriteValue_OpBitRev8(v)
case ssaop.OpBswap16:
- return rewriteValuegeneric_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
- return rewriteValuegeneric_OpBswap32(v)
+ return rewriteValue_OpBswap32(v)
case ssaop.OpBswap64:
- return rewriteValuegeneric_OpBswap64(v)
+ return rewriteValue_OpBswap64(v)
case ssaop.OpCeil:
- return rewriteValuegeneric_OpCeil(v)
+ return rewriteValue_OpCeil(v)
case ssaop.OpCom16:
- return rewriteValuegeneric_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValuegeneric_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom64:
- return rewriteValuegeneric_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpCom8:
- return rewriteValuegeneric_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpCondSelect:
- return rewriteValuegeneric_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConstInterface:
- return rewriteValuegeneric_OpConstInterface(v)
+ return rewriteValue_OpConstInterface(v)
case ssaop.OpConstSlice:
- return rewriteValuegeneric_OpConstSlice(v)
+ return rewriteValue_OpConstSlice(v)
case ssaop.OpConstString:
- return rewriteValuegeneric_OpConstString(v)
+ return rewriteValue_OpConstString(v)
case ssaop.OpConvert:
- return rewriteValuegeneric_OpConvert(v)
+ return rewriteValue_OpConvert(v)
case ssaop.OpCtz16:
- return rewriteValuegeneric_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz32:
- return rewriteValuegeneric_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz64:
- return rewriteValuegeneric_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz8:
- return rewriteValuegeneric_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCvt32Fto32:
- return rewriteValuegeneric_OpCvt32Fto32(v)
+ return rewriteValue_OpCvt32Fto32(v)
case ssaop.OpCvt32Fto64:
- return rewriteValuegeneric_OpCvt32Fto64(v)
+ return rewriteValue_OpCvt32Fto64(v)
case ssaop.OpCvt32Fto64F:
- return rewriteValuegeneric_OpCvt32Fto64F(v)
+ return rewriteValue_OpCvt32Fto64F(v)
case ssaop.OpCvt32to32F:
- return rewriteValuegeneric_OpCvt32to32F(v)
+ return rewriteValue_OpCvt32to32F(v)
case ssaop.OpCvt32to64F:
- return rewriteValuegeneric_OpCvt32to64F(v)
+ return rewriteValue_OpCvt32to64F(v)
case ssaop.OpCvt64Fto32:
- return rewriteValuegeneric_OpCvt64Fto32(v)
+ return rewriteValue_OpCvt64Fto32(v)
case ssaop.OpCvt64Fto32F:
- return rewriteValuegeneric_OpCvt64Fto32F(v)
+ return rewriteValue_OpCvt64Fto32F(v)
case ssaop.OpCvt64Fto64:
- return rewriteValuegeneric_OpCvt64Fto64(v)
+ return rewriteValue_OpCvt64Fto64(v)
case ssaop.OpCvt64to32F:
- return rewriteValuegeneric_OpCvt64to32F(v)
+ return rewriteValue_OpCvt64to32F(v)
case ssaop.OpCvt64to64F:
- return rewriteValuegeneric_OpCvt64to64F(v)
+ return rewriteValue_OpCvt64to64F(v)
case ssaop.OpCvtBoolToUint8:
- return rewriteValuegeneric_OpCvtBoolToUint8(v)
+ return rewriteValue_OpCvtBoolToUint8(v)
case ssaop.OpDiv128u:
- return rewriteValuegeneric_OpDiv128u(v)
+ return rewriteValue_OpDiv128u(v)
case ssaop.OpDiv16:
- return rewriteValuegeneric_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValuegeneric_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValuegeneric_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
- return rewriteValuegeneric_OpDiv32F(v)
+ return rewriteValue_OpDiv32F(v)
case ssaop.OpDiv32u:
- return rewriteValuegeneric_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValuegeneric_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
- return rewriteValuegeneric_OpDiv64F(v)
+ return rewriteValue_OpDiv64F(v)
case ssaop.OpDiv64u:
- return rewriteValuegeneric_OpDiv64u(v)
+ return rewriteValue_OpDiv64u(v)
case ssaop.OpDiv8:
- return rewriteValuegeneric_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValuegeneric_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValuegeneric_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValuegeneric_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValuegeneric_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValuegeneric_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValuegeneric_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValuegeneric_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValuegeneric_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqInter:
- return rewriteValuegeneric_OpEqInter(v)
+ return rewriteValue_OpEqInter(v)
case ssaop.OpEqPtr:
- return rewriteValuegeneric_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpEqSlice:
- return rewriteValuegeneric_OpEqSlice(v)
+ return rewriteValue_OpEqSlice(v)
case ssaop.OpFloor:
- return rewriteValuegeneric_OpFloor(v)
+ return rewriteValue_OpFloor(v)
case ssaop.OpIMake:
- return rewriteValuegeneric_OpIMake(v)
+ return rewriteValue_OpIMake(v)
case ssaop.OpInterLECall:
- return rewriteValuegeneric_OpInterLECall(v)
+ return rewriteValue_OpInterLECall(v)
case ssaop.OpIsInBounds:
- return rewriteValuegeneric_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValuegeneric_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValuegeneric_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValuegeneric_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValuegeneric_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValuegeneric_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValuegeneric_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValuegeneric_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValuegeneric_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValuegeneric_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValuegeneric_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValuegeneric_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValuegeneric_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValuegeneric_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValuegeneric_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValuegeneric_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValuegeneric_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValuegeneric_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValuegeneric_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValuegeneric_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValuegeneric_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValuegeneric_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValuegeneric_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValuegeneric_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLsh16x16:
- return rewriteValuegeneric_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValuegeneric_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValuegeneric_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValuegeneric_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValuegeneric_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValuegeneric_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValuegeneric_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValuegeneric_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValuegeneric_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValuegeneric_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValuegeneric_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValuegeneric_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValuegeneric_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValuegeneric_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValuegeneric_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValuegeneric_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMemEq:
- return rewriteValuegeneric_OpMemEq(v)
+ return rewriteValue_OpMemEq(v)
case ssaop.OpMod16:
- return rewriteValuegeneric_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValuegeneric_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValuegeneric_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValuegeneric_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValuegeneric_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
- return rewriteValuegeneric_OpMod64u(v)
+ return rewriteValue_OpMod64u(v)
case ssaop.OpMod8:
- return rewriteValuegeneric_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValuegeneric_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValuegeneric_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
- return rewriteValuegeneric_OpMul16(v)
+ return rewriteValue_OpMul16(v)
case ssaop.OpMul32:
- return rewriteValuegeneric_OpMul32(v)
+ return rewriteValue_OpMul32(v)
case ssaop.OpMul32F:
- return rewriteValuegeneric_OpMul32F(v)
+ return rewriteValue_OpMul32F(v)
case ssaop.OpMul32uhilo:
- return rewriteValuegeneric_OpMul32uhilo(v)
+ return rewriteValue_OpMul32uhilo(v)
case ssaop.OpMul32uover:
- return rewriteValuegeneric_OpMul32uover(v)
+ return rewriteValue_OpMul32uover(v)
case ssaop.OpMul64:
- return rewriteValuegeneric_OpMul64(v)
+ return rewriteValue_OpMul64(v)
case ssaop.OpMul64F:
- return rewriteValuegeneric_OpMul64F(v)
+ return rewriteValue_OpMul64F(v)
case ssaop.OpMul64uhilo:
- return rewriteValuegeneric_OpMul64uhilo(v)
+ return rewriteValue_OpMul64uhilo(v)
case ssaop.OpMul64uover:
- return rewriteValuegeneric_OpMul64uover(v)
+ return rewriteValue_OpMul64uover(v)
case ssaop.OpMul8:
- return rewriteValuegeneric_OpMul8(v)
+ return rewriteValue_OpMul8(v)
case ssaop.OpNeg16:
- return rewriteValuegeneric_OpNeg16(v)
+ return rewriteValue_OpNeg16(v)
case ssaop.OpNeg32:
- return rewriteValuegeneric_OpNeg32(v)
+ return rewriteValue_OpNeg32(v)
case ssaop.OpNeg32F:
- return rewriteValuegeneric_OpNeg32F(v)
+ return rewriteValue_OpNeg32F(v)
case ssaop.OpNeg64:
- return rewriteValuegeneric_OpNeg64(v)
+ return rewriteValue_OpNeg64(v)
case ssaop.OpNeg64F:
- return rewriteValuegeneric_OpNeg64F(v)
+ return rewriteValue_OpNeg64F(v)
case ssaop.OpNeg8:
- return rewriteValuegeneric_OpNeg8(v)
+ return rewriteValue_OpNeg8(v)
case ssaop.OpNeq16:
- return rewriteValuegeneric_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValuegeneric_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValuegeneric_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValuegeneric_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValuegeneric_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValuegeneric_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
- return rewriteValuegeneric_OpNeqB(v)
+ return rewriteValue_OpNeqB(v)
case ssaop.OpNeqInter:
- return rewriteValuegeneric_OpNeqInter(v)
+ return rewriteValue_OpNeqInter(v)
case ssaop.OpNeqPtr:
- return rewriteValuegeneric_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNeqSlice:
- return rewriteValuegeneric_OpNeqSlice(v)
+ return rewriteValue_OpNeqSlice(v)
case ssaop.OpNilCheck:
- return rewriteValuegeneric_OpNilCheck(v)
+ return rewriteValue_OpNilCheck(v)
case ssaop.OpNot:
- return rewriteValuegeneric_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValuegeneric_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
- return rewriteValuegeneric_OpOr16(v)
+ return rewriteValue_OpOr16(v)
case ssaop.OpOr32:
- return rewriteValuegeneric_OpOr32(v)
+ return rewriteValue_OpOr32(v)
case ssaop.OpOr64:
- return rewriteValuegeneric_OpOr64(v)
+ return rewriteValue_OpOr64(v)
case ssaop.OpOr8:
- return rewriteValuegeneric_OpOr8(v)
+ return rewriteValue_OpOr8(v)
case ssaop.OpOrB:
- return rewriteValuegeneric_OpOrB(v)
+ return rewriteValue_OpOrB(v)
case ssaop.OpPhi:
- return rewriteValuegeneric_OpPhi(v)
+ return rewriteValue_OpPhi(v)
case ssaop.OpPopCount16:
- return rewriteValuegeneric_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValuegeneric_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
- return rewriteValuegeneric_OpPopCount64(v)
+ return rewriteValue_OpPopCount64(v)
case ssaop.OpPopCount8:
- return rewriteValuegeneric_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpPtrIndex:
- return rewriteValuegeneric_OpPtrIndex(v)
+ return rewriteValue_OpPtrIndex(v)
case ssaop.OpRotateLeft16:
- return rewriteValuegeneric_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValuegeneric_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValuegeneric_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValuegeneric_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
- return rewriteValuegeneric_OpRound32F(v)
+ return rewriteValue_OpRound32F(v)
case ssaop.OpRound64F:
- return rewriteValuegeneric_OpRound64F(v)
+ return rewriteValue_OpRound64F(v)
case ssaop.OpRoundToEven:
- return rewriteValuegeneric_OpRoundToEven(v)
+ return rewriteValue_OpRoundToEven(v)
case ssaop.OpRsh16Ux16:
- return rewriteValuegeneric_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValuegeneric_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValuegeneric_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValuegeneric_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValuegeneric_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValuegeneric_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValuegeneric_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValuegeneric_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValuegeneric_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValuegeneric_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValuegeneric_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValuegeneric_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValuegeneric_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValuegeneric_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValuegeneric_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValuegeneric_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValuegeneric_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValuegeneric_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValuegeneric_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValuegeneric_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValuegeneric_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValuegeneric_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValuegeneric_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValuegeneric_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValuegeneric_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValuegeneric_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValuegeneric_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValuegeneric_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValuegeneric_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValuegeneric_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValuegeneric_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValuegeneric_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValuegeneric_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValuegeneric_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSelectN:
- return rewriteValuegeneric_OpSelectN(v)
+ return rewriteValue_OpSelectN(v)
case ssaop.OpSignExt16to32:
- return rewriteValuegeneric_OpSignExt16to32(v)
+ return rewriteValue_OpSignExt16to32(v)
case ssaop.OpSignExt16to64:
- return rewriteValuegeneric_OpSignExt16to64(v)
+ return rewriteValue_OpSignExt16to64(v)
case ssaop.OpSignExt32to64:
- return rewriteValuegeneric_OpSignExt32to64(v)
+ return rewriteValue_OpSignExt32to64(v)
case ssaop.OpSignExt8to16:
- return rewriteValuegeneric_OpSignExt8to16(v)
+ return rewriteValue_OpSignExt8to16(v)
case ssaop.OpSignExt8to32:
- return rewriteValuegeneric_OpSignExt8to32(v)
+ return rewriteValue_OpSignExt8to32(v)
case ssaop.OpSignExt8to64:
- return rewriteValuegeneric_OpSignExt8to64(v)
+ return rewriteValue_OpSignExt8to64(v)
case ssaop.OpSliceCap:
- return rewriteValuegeneric_OpSliceCap(v)
+ return rewriteValue_OpSliceCap(v)
case ssaop.OpSliceLen:
- return rewriteValuegeneric_OpSliceLen(v)
+ return rewriteValue_OpSliceLen(v)
case ssaop.OpSliceMake:
- return rewriteValuegeneric_OpSliceMake(v)
+ return rewriteValue_OpSliceMake(v)
case ssaop.OpSlicePtr:
- return rewriteValuegeneric_OpSlicePtr(v)
+ return rewriteValue_OpSlicePtr(v)
case ssaop.OpSlicemask:
- return rewriteValuegeneric_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
- return rewriteValuegeneric_OpSqrt(v)
+ return rewriteValue_OpSqrt(v)
case ssaop.OpStaticCall:
- return rewriteValuegeneric_OpStaticCall(v)
+ return rewriteValue_OpStaticCall(v)
case ssaop.OpStaticLECall:
- return rewriteValuegeneric_OpStaticLECall(v)
+ return rewriteValue_OpStaticLECall(v)
case ssaop.OpStore:
- return rewriteValuegeneric_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpStringLen:
- return rewriteValuegeneric_OpStringLen(v)
+ return rewriteValue_OpStringLen(v)
case ssaop.OpStringPtr:
- return rewriteValuegeneric_OpStringPtr(v)
+ return rewriteValue_OpStringPtr(v)
case ssaop.OpStructSelect:
- return rewriteValuegeneric_OpStructSelect(v)
+ return rewriteValue_OpStructSelect(v)
case ssaop.OpSub16:
- return rewriteValuegeneric_OpSub16(v)
+ return rewriteValue_OpSub16(v)
case ssaop.OpSub32:
- return rewriteValuegeneric_OpSub32(v)
+ return rewriteValue_OpSub32(v)
case ssaop.OpSub32F:
- return rewriteValuegeneric_OpSub32F(v)
+ return rewriteValue_OpSub32F(v)
case ssaop.OpSub64:
- return rewriteValuegeneric_OpSub64(v)
+ return rewriteValue_OpSub64(v)
case ssaop.OpSub64F:
- return rewriteValuegeneric_OpSub64F(v)
+ return rewriteValue_OpSub64F(v)
case ssaop.OpSub64borrow:
- return rewriteValuegeneric_OpSub64borrow(v)
+ return rewriteValue_OpSub64borrow(v)
case ssaop.OpSub8:
- return rewriteValuegeneric_OpSub8(v)
+ return rewriteValue_OpSub8(v)
case ssaop.OpTrunc:
- return rewriteValuegeneric_OpTrunc(v)
+ return rewriteValue_OpTrunc(v)
case ssaop.OpTrunc16to8:
- return rewriteValuegeneric_OpTrunc16to8(v)
+ return rewriteValue_OpTrunc16to8(v)
case ssaop.OpTrunc32to16:
- return rewriteValuegeneric_OpTrunc32to16(v)
+ return rewriteValue_OpTrunc32to16(v)
case ssaop.OpTrunc32to8:
- return rewriteValuegeneric_OpTrunc32to8(v)
+ return rewriteValue_OpTrunc32to8(v)
case ssaop.OpTrunc64to16:
- return rewriteValuegeneric_OpTrunc64to16(v)
+ return rewriteValue_OpTrunc64to16(v)
case ssaop.OpTrunc64to32:
- return rewriteValuegeneric_OpTrunc64to32(v)
+ return rewriteValue_OpTrunc64to32(v)
case ssaop.OpTrunc64to8:
- return rewriteValuegeneric_OpTrunc64to8(v)
+ return rewriteValue_OpTrunc64to8(v)
case ssaop.OpXor16:
- return rewriteValuegeneric_OpXor16(v)
+ return rewriteValue_OpXor16(v)
case ssaop.OpXor32:
- return rewriteValuegeneric_OpXor32(v)
+ return rewriteValue_OpXor32(v)
case ssaop.OpXor64:
- return rewriteValuegeneric_OpXor64(v)
+ return rewriteValue_OpXor64(v)
case ssaop.OpXor8:
- return rewriteValuegeneric_OpXor8(v)
+ return rewriteValue_OpXor8(v)
case ssaop.OpZero:
- return rewriteValuegeneric_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
- return rewriteValuegeneric_OpZeroExt16to32(v)
+ return rewriteValue_OpZeroExt16to32(v)
case ssaop.OpZeroExt16to64:
- return rewriteValuegeneric_OpZeroExt16to64(v)
+ return rewriteValue_OpZeroExt16to64(v)
case ssaop.OpZeroExt32to64:
- return rewriteValuegeneric_OpZeroExt32to64(v)
+ return rewriteValue_OpZeroExt32to64(v)
case ssaop.OpZeroExt8to16:
- return rewriteValuegeneric_OpZeroExt8to16(v)
+ return rewriteValue_OpZeroExt8to16(v)
case ssaop.OpZeroExt8to32:
- return rewriteValuegeneric_OpZeroExt8to32(v)
+ return rewriteValue_OpZeroExt8to32(v)
case ssaop.OpZeroExt8to64:
- return rewriteValuegeneric_OpZeroExt8to64(v)
+ return rewriteValue_OpZeroExt8to64(v)
}
return false
}
-func rewriteValuegeneric_OpAdd16(v *ssa.Value) bool {
+func rewriteValue_OpAdd16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1164,7 +1164,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd32(v *ssa.Value) bool {
+func rewriteValue_OpAdd32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1814,7 +1814,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd32F(v *ssa.Value) bool {
+func rewriteValue_OpAdd32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F (Const32F [c]) (Const32F [d]))
@@ -1841,7 +1841,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd64(v *ssa.Value) bool {
+func rewriteValue_OpAdd64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2491,7 +2491,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd64F(v *ssa.Value) bool {
+func rewriteValue_OpAdd64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F (Const64F [c]) (Const64F [d]))
@@ -2518,7 +2518,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd64carry(v *ssa.Value) bool {
+func rewriteValue_OpAdd64carry(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2556,7 +2556,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd8(v *ssa.Value) bool {
+func rewriteValue_OpAdd8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3206,7 +3206,7 @@
}
return false
}
-func rewriteValuegeneric_OpAddPtr(v *ssa.Value) bool {
+func rewriteValue_OpAddPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr <t> x (Const64 [c]))
@@ -3241,7 +3241,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd16(v *ssa.Value) bool {
+func rewriteValue_OpAnd16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3498,7 +3498,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd32(v *ssa.Value) bool {
+func rewriteValue_OpAnd32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3755,7 +3755,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd64(v *ssa.Value) bool {
+func rewriteValue_OpAnd64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4012,7 +4012,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAnd8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4269,7 +4269,7 @@
}
return false
}
-func rewriteValuegeneric_OpAndB(v *ssa.Value) bool {
+func rewriteValue_OpAndB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6145,7 +6145,7 @@
}
return false
}
-func rewriteValuegeneric_OpArraySelect(v *ssa.Value) bool {
+func rewriteValue_OpArraySelect(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ArraySelect (ArrayMake1 x))
// result: x
@@ -6170,7 +6170,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -6206,7 +6206,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -6242,7 +6242,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -6278,7 +6278,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -6314,7 +6314,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitRev16(v *ssa.Value) bool {
+func rewriteValue_OpBitRev16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BitRev16 (Const16 [c]))
// result: (Const16 [int16(bits.Reverse16(uint16(c)))])
@@ -6329,7 +6329,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitRev32(v *ssa.Value) bool {
+func rewriteValue_OpBitRev32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BitRev32 (Const32 [c]))
// result: (Const32 [int32(bits.Reverse32(uint32(c)))])
@@ -6344,7 +6344,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitRev64(v *ssa.Value) bool {
+func rewriteValue_OpBitRev64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BitRev64 (Const64 [c]))
// result: (Const64 [int64(bits.Reverse64(uint64(c)))])
@@ -6359,7 +6359,7 @@
}
return false
}
-func rewriteValuegeneric_OpBitRev8(v *ssa.Value) bool {
+func rewriteValue_OpBitRev8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (BitRev8 (Const8 [c]))
// result: (Const8 [int8(bits.Reverse8(uint8(c)))])
@@ -6374,7 +6374,7 @@
}
return false
}
-func rewriteValuegeneric_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Bswap16 (Const16 [c]))
// result: (Const16 [int16(bits.ReverseBytes16(uint16(c)))])
@@ -6389,7 +6389,7 @@
}
return false
}
-func rewriteValuegeneric_OpBswap32(v *ssa.Value) bool {
+func rewriteValue_OpBswap32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Bswap32 (Const32 [c]))
// result: (Const32 [int32(bits.ReverseBytes32(uint32(c)))])
@@ -6404,7 +6404,7 @@
}
return false
}
-func rewriteValuegeneric_OpBswap64(v *ssa.Value) bool {
+func rewriteValue_OpBswap64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Bswap64 (Const64 [c]))
// result: (Const64 [int64(bits.ReverseBytes64(uint64(c)))])
@@ -6419,7 +6419,7 @@
}
return false
}
-func rewriteValuegeneric_OpCeil(v *ssa.Value) bool {
+func rewriteValue_OpCeil(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ceil (Const64F [c]))
// result: (Const64F [math.Ceil(c)])
@@ -6434,7 +6434,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com16 (Com16 x))
// result: x
@@ -6479,7 +6479,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com32 (Com32 x))
// result: x
@@ -6524,7 +6524,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com64 (Com64 x))
// result: x
@@ -6569,7 +6569,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com8 (Com8 x))
// result: x
@@ -6614,7 +6614,7 @@
}
return false
}
-func rewriteValuegeneric_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8380,7 +8380,7 @@
}
return false
}
-func rewriteValuegeneric_OpConstInterface(v *ssa.Value) bool {
+func rewriteValue_OpConstInterface(v *ssa.Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (ConstInterface)
@@ -8393,7 +8393,7 @@
return true
}
}
-func rewriteValuegeneric_OpConstSlice(v *ssa.Value) bool {
+func rewriteValue_OpConstSlice(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -8427,7 +8427,7 @@
}
return false
}
-func rewriteValuegeneric_OpConstString(v *ssa.Value) bool {
+func rewriteValue_OpConstString(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
fe := b.Func.Fe
@@ -8500,7 +8500,7 @@
}
return false
}
-func rewriteValuegeneric_OpConvert(v *ssa.Value) bool {
+func rewriteValue_OpConvert(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8644,7 +8644,7 @@
}
return false
}
-func rewriteValuegeneric_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -8680,7 +8680,7 @@
}
return false
}
-func rewriteValuegeneric_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -8716,7 +8716,7 @@
}
return false
}
-func rewriteValuegeneric_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -8752,7 +8752,7 @@
}
return false
}
-func rewriteValuegeneric_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -8788,7 +8788,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 (Const32F [c]))
// cond: c >= -1<<31 && c < 1<<31
@@ -8807,7 +8807,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 (Const32F [c]))
// cond: c >= -1<<63 && c < 1<<63
@@ -8826,7 +8826,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F (Const32F [c]))
// result: (Const64F [float64(c)])
@@ -8841,7 +8841,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32to32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F (Const32 [c]))
// result: (Const32F [float32(c)])
@@ -8856,7 +8856,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32to64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F (Const32 [c]))
// result: (Const64F [float64(c)])
@@ -8871,7 +8871,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 (Const64F [c]))
// cond: c >= -1<<31 && c < 1<<31
@@ -8890,7 +8890,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F (Const64F [c]))
// result: (Const32F [float32(c)])
@@ -8925,7 +8925,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 (Const64F [c]))
// cond: c >= -1<<63 && c < 1<<63
@@ -8944,7 +8944,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64to32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt64to32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F (Const64 [c]))
// result: (Const32F [float32(c)])
@@ -8959,7 +8959,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64to64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt64to64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F (Const64 [c]))
// result: (Const64F [float64(c)])
@@ -8974,7 +8974,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvtBoolToUint8(v *ssa.Value) bool {
+func rewriteValue_OpCvtBoolToUint8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CvtBoolToUint8 (ConstBool [false]))
// result: (Const8 [0])
@@ -8998,7 +8998,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv128u(v *ssa.Value) bool {
+func rewriteValue_OpDiv128u(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9050,7 +9050,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9115,7 +9115,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9159,7 +9159,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9224,7 +9224,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32F(v *ssa.Value) bool {
+func rewriteValue_OpDiv32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9268,7 +9268,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9312,7 +9312,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9389,7 +9389,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64F(v *ssa.Value) bool {
+func rewriteValue_OpDiv64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9433,7 +9433,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64u(v *ssa.Value) bool {
+func rewriteValue_OpDiv64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9477,7 +9477,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9542,7 +9542,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9586,7 +9586,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10002,7 +10002,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10352,7 +10352,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq32F (Const32F [c]) (Const32F [d]))
@@ -10375,7 +10375,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10725,7 +10725,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq64F (Const64F [c]) (Const64F [d]))
@@ -10748,7 +10748,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11156,7 +11156,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqB x x)
@@ -11232,7 +11232,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqInter(v *ssa.Value) bool {
+func rewriteValue_OpEqInter(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11251,7 +11251,7 @@
return true
}
}
-func rewriteValuegeneric_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11647,7 +11647,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqSlice(v *ssa.Value) bool {
+func rewriteValue_OpEqSlice(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11666,7 +11666,7 @@
return true
}
}
-func rewriteValuegeneric_OpFloor(v *ssa.Value) bool {
+func rewriteValue_OpFloor(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Floor (Const64F [c]))
// result: (Const64F [math.Floor(c)])
@@ -11681,7 +11681,7 @@
}
return false
}
-func rewriteValuegeneric_OpIMake(v *ssa.Value) bool {
+func rewriteValue_OpIMake(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IMake _typ (StructMake ___))
@@ -11707,7 +11707,7 @@
}
return false
}
-func rewriteValuegeneric_OpInterLECall(v *ssa.Value) bool {
+func rewriteValue_OpInterLECall(v *ssa.Value) bool {
// match: (InterLECall [argsize] {auxCall} (Addr {fn} (SB)) ___)
// result: devirtLECall(v, fn.(*obj.LSym))
for {
@@ -11728,7 +11728,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
@@ -12420,7 +12420,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (IsNonNil (ConstNil))
// result: (ConstBool [false])
@@ -12490,7 +12490,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsSliceInBounds x x)
@@ -12624,7 +12624,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12785,7 +12785,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12867,7 +12867,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13028,7 +13028,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32F (Const32F [c]) (Const32F [d]))
@@ -13048,7 +13048,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13130,7 +13130,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13291,7 +13291,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64F (Const64F [c]) (Const64F [d]))
@@ -13311,7 +13311,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13393,7 +13393,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13554,7 +13554,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13636,7 +13636,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13766,7 +13766,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13875,7 +13875,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14005,7 +14005,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32F (Const32F [c]) (Const32F [d]))
@@ -14025,7 +14025,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14134,7 +14134,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14264,7 +14264,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64F (Const64F [c]) (Const64F [d]))
@@ -14284,7 +14284,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14393,7 +14393,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14523,7 +14523,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14632,7 +14632,7 @@
}
return false
}
-func rewriteValuegeneric_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15539,7 +15539,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15590,7 +15590,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15641,7 +15641,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16016,7 +16016,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16067,7 +16067,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16118,7 +16118,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16169,7 +16169,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16544,7 +16544,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16595,7 +16595,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16646,7 +16646,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16697,7 +16697,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17072,7 +17072,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17123,7 +17123,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17174,7 +17174,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17225,7 +17225,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17600,7 +17600,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17651,7 +17651,7 @@
}
return false
}
-func rewriteValuegeneric_OpMemEq(v *ssa.Value) bool {
+func rewriteValue_OpMemEq(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -17937,7 +17937,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18024,7 +18024,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18091,7 +18091,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18178,7 +18178,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18245,7 +18245,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18343,7 +18343,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod64u(v *ssa.Value) bool {
+func rewriteValue_OpMod64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18410,7 +18410,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18497,7 +18497,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18564,7 +18564,7 @@
}
return false
}
-func rewriteValuegeneric_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19903,7 +19903,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul16(v *ssa.Value) bool {
+func rewriteValue_OpMul16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20158,7 +20158,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32(v *ssa.Value) bool {
+func rewriteValue_OpMul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20413,7 +20413,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32F(v *ssa.Value) bool {
+func rewriteValue_OpMul32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F (Const32F [c]) (Const32F [d]))
@@ -20481,7 +20481,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32uhilo(v *ssa.Value) bool {
+func rewriteValue_OpMul32uhilo(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20510,7 +20510,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32uover(v *ssa.Value) bool {
+func rewriteValue_OpMul32uover(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20574,7 +20574,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64(v *ssa.Value) bool {
+func rewriteValue_OpMul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20829,7 +20829,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64F(v *ssa.Value) bool {
+func rewriteValue_OpMul64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F (Const64F [c]) (Const64F [d]))
@@ -20897,7 +20897,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64uhilo(v *ssa.Value) bool {
+func rewriteValue_OpMul64uhilo(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20953,7 +20953,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64uover(v *ssa.Value) bool {
+func rewriteValue_OpMul64uover(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21017,7 +21017,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul8(v *ssa.Value) bool {
+func rewriteValue_OpMul8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21272,7 +21272,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg16(v *ssa.Value) bool {
+func rewriteValue_OpNeg16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg16 (Const16 [c]))
@@ -21369,7 +21369,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg32(v *ssa.Value) bool {
+func rewriteValue_OpNeg32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg32 (Const32 [c]))
@@ -21466,7 +21466,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg32F(v *ssa.Value) bool {
+func rewriteValue_OpNeg32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Neg32F (Const32F [c]))
// cond: c != 0
@@ -21485,7 +21485,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg64(v *ssa.Value) bool {
+func rewriteValue_OpNeg64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg64 (Const64 [c]))
@@ -21582,7 +21582,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg64F(v *ssa.Value) bool {
+func rewriteValue_OpNeg64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Neg64F (Const64F [c]))
// cond: c != 0
@@ -21601,7 +21601,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg8(v *ssa.Value) bool {
+func rewriteValue_OpNeg8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg8 (Const8 [c]))
@@ -21698,7 +21698,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22048,7 +22048,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22398,7 +22398,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq32F (Const32F [c]) (Const32F [d]))
@@ -22421,7 +22421,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22771,7 +22771,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq64F (Const64F [c]) (Const64F [d]))
@@ -22794,7 +22794,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23136,7 +23136,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqB(v *ssa.Value) bool {
+func rewriteValue_OpNeqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x x)
@@ -23212,7 +23212,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqInter(v *ssa.Value) bool {
+func rewriteValue_OpNeqInter(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23231,7 +23231,7 @@
return true
}
}
-func rewriteValuegeneric_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqPtr x x)
@@ -23617,7 +23617,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqSlice(v *ssa.Value) bool {
+func rewriteValue_OpNeqSlice(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23636,7 +23636,7 @@
return true
}
}
-func rewriteValuegeneric_OpNilCheck(v *ssa.Value) bool {
+func rewriteValue_OpNilCheck(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23765,7 +23765,7 @@
}
return false
}
-func rewriteValuegeneric_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not (ConstBool [c]))
// result: (ConstBool [!c])
@@ -24164,7 +24164,7 @@
}
return false
}
-func rewriteValuegeneric_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr (OffPtr p [y]) [x])
// result: (OffPtr p [x+y])
@@ -24196,7 +24196,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr16(v *ssa.Value) bool {
+func rewriteValue_OpOr16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24742,7 +24742,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr32(v *ssa.Value) bool {
+func rewriteValue_OpOr32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25288,7 +25288,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr64(v *ssa.Value) bool {
+func rewriteValue_OpOr64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25834,7 +25834,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr8(v *ssa.Value) bool {
+func rewriteValue_OpOr8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26380,7 +26380,7 @@
}
return false
}
-func rewriteValuegeneric_OpOrB(v *ssa.Value) bool {
+func rewriteValue_OpOrB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28481,7 +28481,7 @@
}
return false
}
-func rewriteValuegeneric_OpPhi(v *ssa.Value) bool {
+func rewriteValue_OpPhi(v *ssa.Value) bool {
b := v.Block
// match: (Phi (Const8 [c]) (Const8 [c]))
// result: (Const8 [c])
@@ -28593,7 +28593,7 @@
}
return false
}
-func rewriteValuegeneric_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -28629,7 +28629,7 @@
}
return false
}
-func rewriteValuegeneric_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -28665,7 +28665,7 @@
}
return false
}
-func rewriteValuegeneric_OpPopCount64(v *ssa.Value) bool {
+func rewriteValue_OpPopCount64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -28701,7 +28701,7 @@
}
return false
}
-func rewriteValuegeneric_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -28737,7 +28737,7 @@
}
return false
}
-func rewriteValuegeneric_OpPtrIndex(v *ssa.Value) bool {
+func rewriteValue_OpPtrIndex(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28781,7 +28781,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -29356,7 +29356,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -29931,7 +29931,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -30506,7 +30506,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31081,7 +31081,7 @@
}
return false
}
-func rewriteValuegeneric_OpRound32F(v *ssa.Value) bool {
+func rewriteValue_OpRound32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Round32F x:(Const32F))
// result: x
@@ -31095,7 +31095,7 @@
}
return false
}
-func rewriteValuegeneric_OpRound64F(v *ssa.Value) bool {
+func rewriteValue_OpRound64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Round64F x:(Const64F))
// result: x
@@ -31109,7 +31109,7 @@
}
return false
}
-func rewriteValuegeneric_OpRoundToEven(v *ssa.Value) bool {
+func rewriteValue_OpRoundToEven(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven (Const64F [c]))
// result: (Const64F [math.RoundToEven(c)])
@@ -31124,7 +31124,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31175,7 +31175,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31226,7 +31226,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31431,7 +31431,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31482,7 +31482,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31533,7 +31533,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31584,7 +31584,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31693,7 +31693,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31744,7 +31744,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31795,7 +31795,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31846,7 +31846,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32069,7 +32069,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32120,7 +32120,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32171,7 +32171,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32222,7 +32222,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32349,7 +32349,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32400,7 +32400,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32451,7 +32451,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32502,7 +32502,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32743,7 +32743,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32794,7 +32794,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32845,7 +32845,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32896,7 +32896,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33041,7 +33041,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33092,7 +33092,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33143,7 +33143,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33194,7 +33194,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33381,7 +33381,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33432,7 +33432,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33483,7 +33483,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33534,7 +33534,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33624,7 +33624,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33675,7 +33675,7 @@
}
return false
}
-func rewriteValuegeneric_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select0 a:(Add64carry x y (Const64 [0])))
// cond: a.Uses == 1
@@ -33708,7 +33708,7 @@
}
return false
}
-func rewriteValuegeneric_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select1 (MakeTuple x y))
// result: y
@@ -33722,7 +33722,7 @@
}
return false
}
-func rewriteValuegeneric_OpSelectN(v *ssa.Value) bool {
+func rewriteValue_OpSelectN(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -34117,7 +34117,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt16to32(v *ssa.Value) bool {
+func rewriteValue_OpSignExt16to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 (Const16 [c]))
// result: (Const32 [int32(c)])
@@ -34155,7 +34155,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 (Const16 [c]))
// result: (Const64 [int64(c)])
@@ -34193,7 +34193,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 (Const32 [c]))
// result: (Const64 [int64(c)])
@@ -34231,7 +34231,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to16(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 (Const8 [c]))
// result: (Const16 [int16(c)])
@@ -34280,7 +34280,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to32(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 (Const8 [c]))
// result: (Const32 [int32(c)])
@@ -34329,7 +34329,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 (Const8 [c]))
// result: (Const64 [int64(c)])
@@ -34378,7 +34378,7 @@
}
return false
}
-func rewriteValuegeneric_OpSliceCap(v *ssa.Value) bool {
+func rewriteValue_OpSliceCap(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
// result: (Const64 <t> [c])
@@ -34473,7 +34473,7 @@
}
return false
}
-func rewriteValuegeneric_OpSliceLen(v *ssa.Value) bool {
+func rewriteValue_OpSliceLen(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
// result: (Const64 <t> [c])
@@ -34592,7 +34592,7 @@
}
return false
}
-func rewriteValuegeneric_OpSliceMake(v *ssa.Value) bool {
+func rewriteValue_OpSliceMake(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34677,7 +34677,7 @@
}
return false
}
-func rewriteValuegeneric_OpSlicePtr(v *ssa.Value) bool {
+func rewriteValue_OpSlicePtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
// result: (SlicePtr x)
@@ -34696,7 +34696,7 @@
}
return false
}
-func rewriteValuegeneric_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Slicemask (Const32 [x]))
// cond: x > 0
@@ -34750,7 +34750,7 @@
}
return false
}
-func rewriteValuegeneric_OpSqrt(v *ssa.Value) bool {
+func rewriteValue_OpSqrt(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Sqrt (Const64F [c]))
// cond: !math.IsNaN(math.Sqrt(c))
@@ -34769,7 +34769,7 @@
}
return false
}
-func rewriteValuegeneric_OpStaticCall(v *ssa.Value) bool {
+func rewriteValue_OpStaticCall(v *ssa.Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (StaticCall {callAux} p q _ mem)
@@ -34794,7 +34794,7 @@
}
return false
}
-func rewriteValuegeneric_OpStaticLECall(v *ssa.Value) bool {
+func rewriteValue_OpStaticLECall(v *ssa.Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -35650,7 +35650,7 @@
}
return false
}
-func rewriteValuegeneric_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -35770,7 +35770,7 @@
return true
}
// match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
- // cond: isConstZero(x) && o >= 0 && t.Size() + o <= n && ssa.IsSamePtr(p1, p2)
+ // cond: ssa.IsConstZero(x) && o >= 0 && t.Size() + o <= n && ssa.IsSamePtr(p1, p2)
// result: mem
for {
t := ssa.AuxToType(v.Aux)
@@ -35786,14 +35786,14 @@
}
n := ssa.AuxIntToInt64(mem.AuxInt)
p2 := mem.Args[0]
- if !(isConstZero(x) && o >= 0 && t.Size()+o <= n && ssa.IsSamePtr(p1, p2)) {
+ if !(ssa.IsConstZero(x) && o >= 0 && t.Size()+o <= n && ssa.IsSamePtr(p1, p2)) {
break
}
v.CopyOf(mem)
return true
}
// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
- // cond: isConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)
+ // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)
// result: mem
for {
t1 := ssa.AuxToType(v.Aux)
@@ -35817,14 +35817,14 @@
}
n := ssa.AuxIntToInt64(mem_2.AuxInt)
p3 := mem_2.Args[0]
- if !(isConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)) {
+ if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)) {
break
}
v.CopyOf(mem)
return true
}
// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
- // cond: isConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)
+ // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)
// result: mem
for {
t1 := ssa.AuxToType(v.Aux)
@@ -35855,14 +35855,14 @@
}
n := ssa.AuxIntToInt64(mem_2_2.AuxInt)
p4 := mem_2_2.Args[0]
- if !(isConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) {
+ if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) {
break
}
v.CopyOf(mem)
return true
}
// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
- // cond: isConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)
+ // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)
// result: mem
for {
t1 := ssa.AuxToType(v.Aux)
@@ -35900,7 +35900,7 @@
}
n := ssa.AuxIntToInt64(mem_2_2_2.AuxInt)
p5 := mem_2_2_2.Args[0]
- if !(isConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) {
+ if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) {
break
}
v.CopyOf(mem)
@@ -35987,7 +35987,7 @@
return true
}
// match: (Store (SelectN [0] call:(StaticLECall ___)) x mem:(SelectN [1] call))
- // cond: isConstZero(x) && isMalloc(call.Aux)
+ // cond: ssa.IsConstZero(x) && isMalloc(call.Aux)
// result: mem
for {
if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
@@ -35999,14 +35999,14 @@
}
x := v_1
mem := v_2
- if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(isConstZero(x) && isMalloc(call.Aux)) {
+ if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) {
break
}
v.CopyOf(mem)
return true
}
// match: (Store (OffPtr (SelectN [0] call:(StaticLECall ___))) x mem:(SelectN [1] call))
- // cond: isConstZero(x) && isMalloc(call.Aux)
+ // cond: ssa.IsConstZero(x) && isMalloc(call.Aux)
// result: mem
for {
if v_0.Op != ssaop.OpOffPtr {
@@ -36022,7 +36022,7 @@
}
x := v_1
mem := v_2
- if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(isConstZero(x) && isMalloc(call.Aux)) {
+ if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) {
break
}
v.CopyOf(mem)
@@ -36378,7 +36378,7 @@
}
return false
}
-func rewriteValuegeneric_OpStringLen(v *ssa.Value) bool {
+func rewriteValue_OpStringLen(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (StringLen (StringMake _ (Const64 <t> [c])))
// result: (Const64 <t> [c])
@@ -36400,7 +36400,7 @@
}
return false
}
-func rewriteValuegeneric_OpStringPtr(v *ssa.Value) bool {
+func rewriteValue_OpStringPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (StringPtr (StringMake (Addr <t> {s} base) _))
// result: (Addr <t> {s} base)
@@ -36423,7 +36423,7 @@
}
return false
}
-func rewriteValuegeneric_OpStructSelect(v *ssa.Value) bool {
+func rewriteValue_OpStructSelect(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (StructSelect [i] x:(StructMake ___))
@@ -36491,7 +36491,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub16(v *ssa.Value) bool {
+func rewriteValue_OpSub16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36888,7 +36888,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub32(v *ssa.Value) bool {
+func rewriteValue_OpSub32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37285,7 +37285,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub32F(v *ssa.Value) bool {
+func rewriteValue_OpSub32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F (Const32F [c]) (Const32F [d]))
@@ -37309,7 +37309,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub64(v *ssa.Value) bool {
+func rewriteValue_OpSub64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37706,7 +37706,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub64F(v *ssa.Value) bool {
+func rewriteValue_OpSub64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F (Const64F [c]) (Const64F [d]))
@@ -37730,7 +37730,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub64borrow(v *ssa.Value) bool {
+func rewriteValue_OpSub64borrow(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -37765,7 +37765,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub8(v *ssa.Value) bool {
+func rewriteValue_OpSub8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38162,7 +38162,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc(v *ssa.Value) bool {
+func rewriteValue_OpTrunc(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc (Const64F [c]))
// result: (Const64F [math.Trunc(c)])
@@ -38177,7 +38177,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc16to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc16to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 (Const16 [c]))
// result: (Const8 [int8(c)])
@@ -38237,7 +38237,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc32to16(v *ssa.Value) bool {
+func rewriteValue_OpTrunc32to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 (Const32 [c]))
// result: (Const16 [int16(c)])
@@ -38319,7 +38319,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc32to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc32to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 (Const32 [c]))
// result: (Const8 [int8(c)])
@@ -38379,7 +38379,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to16(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 (Const64 [c]))
// result: (Const16 [int16(c)])
@@ -38461,7 +38461,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to32(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 (Const64 [c]))
// result: (Const32 [int32(c)])
@@ -38565,7 +38565,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 (Const64 [c]))
// result: (Const8 [int8(c)])
@@ -38625,7 +38625,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor16(v *ssa.Value) bool {
+func rewriteValue_OpXor16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39162,7 +39162,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor32(v *ssa.Value) bool {
+func rewriteValue_OpXor32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39699,7 +39699,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor64(v *ssa.Value) bool {
+func rewriteValue_OpXor64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40236,7 +40236,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor8(v *ssa.Value) bool {
+func rewriteValue_OpXor8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40759,7 +40759,7 @@
}
return false
}
-func rewriteValuegeneric_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40903,7 +40903,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to32(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt16to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 (Const16 [c]))
// result: (Const32 [int32(uint16(c))])
@@ -40941,7 +40941,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 (Const16 [c]))
// result: (Const64 [int64(uint16(c))])
@@ -40979,7 +40979,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 (Const32 [c]))
// result: (Const64 [int64(uint32(c))])
@@ -41017,7 +41017,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to16(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 (Const8 [c]))
// result: (Const16 [int16( uint8(c))])
@@ -41055,7 +41055,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to32(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 (Const8 [c]))
// result: (Const32 [int32( uint8(c))])
@@ -41093,7 +41093,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 (Const8 [c]))
// result: (Const64 [int64( uint8(c))])
@@ -41131,7 +41131,7 @@
}
return false
}
-func rewriteBlockgeneric(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.BlockIf:
// match: (If (Not cond) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/rewriteLOONG64.go b/src/cmd/compile/internal/ssarewrite/rewriteloong64/rewriteLOONG64.go
similarity index 92%
rename from src/cmd/compile/internal/ssacompile/rewriteLOONG64.go
rename to src/cmd/compile/internal/ssarewrite/rewriteloong64/rewriteLOONG64.go
index 246f28e..36ff12b 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteLOONG64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteloong64/rewriteLOONG64.go
@@ -1,13 +1,13 @@
// Code generated from _gen/LOONG64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteloong64
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueLOONG64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpLOONG64ABSD
@@ -34,7 +34,7 @@
v.Op = ssaop.OpLOONG64ADDV
return true
case ssaop.OpAddr:
- return rewriteValueLOONG64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpLOONG64AND
return true
@@ -66,11 +66,11 @@
v.Op = ssaop.OpLOONG64LoweredAtomicAnd64value
return true
case ssaop.OpAtomicAnd8:
- return rewriteValueLOONG64_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValueLOONG64_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap32Variant:
- return rewriteValueLOONG64_OpAtomicCompareAndSwap32Variant(v)
+ return rewriteValue_OpAtomicCompareAndSwap32Variant(v)
case ssaop.OpAtomicCompareAndSwap64:
v.Op = ssaop.OpLOONG64LoweredAtomicCas64
return true
@@ -108,7 +108,7 @@
v.Op = ssaop.OpLOONG64LoweredAtomicOr64value
return true
case ssaop.OpAtomicOr8:
- return rewriteValueLOONG64_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
v.Op = ssaop.OpLOONG64LoweredAtomicStore32
return true
@@ -131,17 +131,17 @@
v.Op = ssaop.OpLOONG64LoweredAtomicStore64
return true
case ssaop.OpAvg64u:
- return rewriteValueLOONG64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValueLOONG64_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueLOONG64_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueLOONG64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueLOONG64_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBitRev16:
- return rewriteValueLOONG64_OpBitRev16(v)
+ return rewriteValue_OpBitRev16(v)
case ssaop.OpBitRev32:
v.Op = ssaop.OpLOONG64BITREVW
return true
@@ -167,36 +167,36 @@
v.Op = ssaop.OpLOONG64CALLclosure
return true
case ssaop.OpCom16:
- return rewriteValueLOONG64_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValueLOONG64_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom64:
- return rewriteValueLOONG64_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpCom8:
- return rewriteValueLOONG64_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpCondSelect:
- return rewriteValueLOONG64_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConst16:
- return rewriteValueLOONG64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueLOONG64_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
- return rewriteValueLOONG64_OpConst32F(v)
+ return rewriteValue_OpConst32F(v)
case ssaop.OpConst64:
- return rewriteValueLOONG64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
- return rewriteValueLOONG64_OpConst64F(v)
+ return rewriteValue_OpConst64F(v)
case ssaop.OpConst8:
- return rewriteValueLOONG64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueLOONG64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueLOONG64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCopysign:
v.Op = ssaop.OpLOONG64FCOPYSGD
return true
case ssaop.OpCtz16:
- return rewriteValueLOONG64_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz64
return true
@@ -213,7 +213,7 @@
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz8:
- return rewriteValueLOONG64_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz64
return true
@@ -251,18 +251,18 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueLOONG64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueLOONG64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueLOONG64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpLOONG64DIVF
return true
case ssaop.OpDiv32u:
- return rewriteValueLOONG64_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValueLOONG64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpLOONG64DIVD
return true
@@ -270,25 +270,25 @@
v.Op = ssaop.OpLOONG64DIVVU
return true
case ssaop.OpDiv8:
- return rewriteValueLOONG64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueLOONG64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueLOONG64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueLOONG64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueLOONG64_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValueLOONG64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValueLOONG64_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueLOONG64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueLOONG64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueLOONG64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpFMA:
v.Op = ssaop.OpLOONG64FMADDD
return true
@@ -320,255 +320,255 @@
v.Op = ssaop.OpLOONG64CALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValueLOONG64_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueLOONG64_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueLOONG64_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLOONG64ADDD:
- return rewriteValueLOONG64_OpLOONG64ADDD(v)
+ return rewriteValue_OpLOONG64ADDD(v)
case ssaop.OpLOONG64ADDF:
- return rewriteValueLOONG64_OpLOONG64ADDF(v)
+ return rewriteValue_OpLOONG64ADDF(v)
case ssaop.OpLOONG64ADDV:
- return rewriteValueLOONG64_OpLOONG64ADDV(v)
+ return rewriteValue_OpLOONG64ADDV(v)
case ssaop.OpLOONG64ADDVconst:
- return rewriteValueLOONG64_OpLOONG64ADDVconst(v)
+ return rewriteValue_OpLOONG64ADDVconst(v)
case ssaop.OpLOONG64ADDshiftLLV:
- return rewriteValueLOONG64_OpLOONG64ADDshiftLLV(v)
+ return rewriteValue_OpLOONG64ADDshiftLLV(v)
case ssaop.OpLOONG64AND:
- return rewriteValueLOONG64_OpLOONG64AND(v)
+ return rewriteValue_OpLOONG64AND(v)
case ssaop.OpLOONG64ANDconst:
- return rewriteValueLOONG64_OpLOONG64ANDconst(v)
+ return rewriteValue_OpLOONG64ANDconst(v)
case ssaop.OpLOONG64DIVV:
- return rewriteValueLOONG64_OpLOONG64DIVV(v)
+ return rewriteValue_OpLOONG64DIVV(v)
case ssaop.OpLOONG64DIVVU:
- return rewriteValueLOONG64_OpLOONG64DIVVU(v)
+ return rewriteValue_OpLOONG64DIVVU(v)
case ssaop.OpLOONG64LoweredPanicBoundsCR:
- return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpLOONG64LoweredPanicBoundsCR(v)
case ssaop.OpLOONG64LoweredPanicBoundsRC:
- return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpLOONG64LoweredPanicBoundsRC(v)
case ssaop.OpLOONG64LoweredPanicBoundsRR:
- return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpLOONG64LoweredPanicBoundsRR(v)
case ssaop.OpLOONG64MASKEQZ:
- return rewriteValueLOONG64_OpLOONG64MASKEQZ(v)
+ return rewriteValue_OpLOONG64MASKEQZ(v)
case ssaop.OpLOONG64MASKNEZ:
- return rewriteValueLOONG64_OpLOONG64MASKNEZ(v)
+ return rewriteValue_OpLOONG64MASKNEZ(v)
case ssaop.OpLOONG64MOVBUload:
- return rewriteValueLOONG64_OpLOONG64MOVBUload(v)
+ return rewriteValue_OpLOONG64MOVBUload(v)
case ssaop.OpLOONG64MOVBUloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVBUloadidx(v)
+ return rewriteValue_OpLOONG64MOVBUloadidx(v)
case ssaop.OpLOONG64MOVBUreg:
- return rewriteValueLOONG64_OpLOONG64MOVBUreg(v)
+ return rewriteValue_OpLOONG64MOVBUreg(v)
case ssaop.OpLOONG64MOVBload:
- return rewriteValueLOONG64_OpLOONG64MOVBload(v)
+ return rewriteValue_OpLOONG64MOVBload(v)
case ssaop.OpLOONG64MOVBloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVBloadidx(v)
+ return rewriteValue_OpLOONG64MOVBloadidx(v)
case ssaop.OpLOONG64MOVBreg:
- return rewriteValueLOONG64_OpLOONG64MOVBreg(v)
+ return rewriteValue_OpLOONG64MOVBreg(v)
case ssaop.OpLOONG64MOVBstore:
- return rewriteValueLOONG64_OpLOONG64MOVBstore(v)
+ return rewriteValue_OpLOONG64MOVBstore(v)
case ssaop.OpLOONG64MOVBstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVBstoreidx(v)
+ return rewriteValue_OpLOONG64MOVBstoreidx(v)
case ssaop.OpLOONG64MOVDF:
- return rewriteValueLOONG64_OpLOONG64MOVDF(v)
+ return rewriteValue_OpLOONG64MOVDF(v)
case ssaop.OpLOONG64MOVDload:
- return rewriteValueLOONG64_OpLOONG64MOVDload(v)
+ return rewriteValue_OpLOONG64MOVDload(v)
case ssaop.OpLOONG64MOVDloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVDloadidx(v)
+ return rewriteValue_OpLOONG64MOVDloadidx(v)
case ssaop.OpLOONG64MOVDstore:
- return rewriteValueLOONG64_OpLOONG64MOVDstore(v)
+ return rewriteValue_OpLOONG64MOVDstore(v)
case ssaop.OpLOONG64MOVDstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVDstoreidx(v)
+ return rewriteValue_OpLOONG64MOVDstoreidx(v)
case ssaop.OpLOONG64MOVFload:
- return rewriteValueLOONG64_OpLOONG64MOVFload(v)
+ return rewriteValue_OpLOONG64MOVFload(v)
case ssaop.OpLOONG64MOVFloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVFloadidx(v)
+ return rewriteValue_OpLOONG64MOVFloadidx(v)
case ssaop.OpLOONG64MOVFstore:
- return rewriteValueLOONG64_OpLOONG64MOVFstore(v)
+ return rewriteValue_OpLOONG64MOVFstore(v)
case ssaop.OpLOONG64MOVFstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVFstoreidx(v)
+ return rewriteValue_OpLOONG64MOVFstoreidx(v)
case ssaop.OpLOONG64MOVHUload:
- return rewriteValueLOONG64_OpLOONG64MOVHUload(v)
+ return rewriteValue_OpLOONG64MOVHUload(v)
case ssaop.OpLOONG64MOVHUloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVHUloadidx(v)
+ return rewriteValue_OpLOONG64MOVHUloadidx(v)
case ssaop.OpLOONG64MOVHUreg:
- return rewriteValueLOONG64_OpLOONG64MOVHUreg(v)
+ return rewriteValue_OpLOONG64MOVHUreg(v)
case ssaop.OpLOONG64MOVHload:
- return rewriteValueLOONG64_OpLOONG64MOVHload(v)
+ return rewriteValue_OpLOONG64MOVHload(v)
case ssaop.OpLOONG64MOVHloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVHloadidx(v)
+ return rewriteValue_OpLOONG64MOVHloadidx(v)
case ssaop.OpLOONG64MOVHreg:
- return rewriteValueLOONG64_OpLOONG64MOVHreg(v)
+ return rewriteValue_OpLOONG64MOVHreg(v)
case ssaop.OpLOONG64MOVHstore:
- return rewriteValueLOONG64_OpLOONG64MOVHstore(v)
+ return rewriteValue_OpLOONG64MOVHstore(v)
case ssaop.OpLOONG64MOVHstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVHstoreidx(v)
+ return rewriteValue_OpLOONG64MOVHstoreidx(v)
case ssaop.OpLOONG64MOVVload:
- return rewriteValueLOONG64_OpLOONG64MOVVload(v)
+ return rewriteValue_OpLOONG64MOVVload(v)
case ssaop.OpLOONG64MOVVloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVVloadidx(v)
+ return rewriteValue_OpLOONG64MOVVloadidx(v)
case ssaop.OpLOONG64MOVVnop:
- return rewriteValueLOONG64_OpLOONG64MOVVnop(v)
+ return rewriteValue_OpLOONG64MOVVnop(v)
case ssaop.OpLOONG64MOVVreg:
- return rewriteValueLOONG64_OpLOONG64MOVVreg(v)
+ return rewriteValue_OpLOONG64MOVVreg(v)
case ssaop.OpLOONG64MOVVstore:
- return rewriteValueLOONG64_OpLOONG64MOVVstore(v)
+ return rewriteValue_OpLOONG64MOVVstore(v)
case ssaop.OpLOONG64MOVVstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVVstoreidx(v)
+ return rewriteValue_OpLOONG64MOVVstoreidx(v)
case ssaop.OpLOONG64MOVWUload:
- return rewriteValueLOONG64_OpLOONG64MOVWUload(v)
+ return rewriteValue_OpLOONG64MOVWUload(v)
case ssaop.OpLOONG64MOVWUloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVWUloadidx(v)
+ return rewriteValue_OpLOONG64MOVWUloadidx(v)
case ssaop.OpLOONG64MOVWUreg:
- return rewriteValueLOONG64_OpLOONG64MOVWUreg(v)
+ return rewriteValue_OpLOONG64MOVWUreg(v)
case ssaop.OpLOONG64MOVWload:
- return rewriteValueLOONG64_OpLOONG64MOVWload(v)
+ return rewriteValue_OpLOONG64MOVWload(v)
case ssaop.OpLOONG64MOVWloadidx:
- return rewriteValueLOONG64_OpLOONG64MOVWloadidx(v)
+ return rewriteValue_OpLOONG64MOVWloadidx(v)
case ssaop.OpLOONG64MOVWreg:
- return rewriteValueLOONG64_OpLOONG64MOVWreg(v)
+ return rewriteValue_OpLOONG64MOVWreg(v)
case ssaop.OpLOONG64MOVWstore:
- return rewriteValueLOONG64_OpLOONG64MOVWstore(v)
+ return rewriteValue_OpLOONG64MOVWstore(v)
case ssaop.OpLOONG64MOVWstoreidx:
- return rewriteValueLOONG64_OpLOONG64MOVWstoreidx(v)
+ return rewriteValue_OpLOONG64MOVWstoreidx(v)
case ssaop.OpLOONG64MULV:
- return rewriteValueLOONG64_OpLOONG64MULV(v)
+ return rewriteValue_OpLOONG64MULV(v)
case ssaop.OpLOONG64NEGV:
- return rewriteValueLOONG64_OpLOONG64NEGV(v)
+ return rewriteValue_OpLOONG64NEGV(v)
case ssaop.OpLOONG64NOR:
- return rewriteValueLOONG64_OpLOONG64NOR(v)
+ return rewriteValue_OpLOONG64NOR(v)
case ssaop.OpLOONG64NORconst:
- return rewriteValueLOONG64_OpLOONG64NORconst(v)
+ return rewriteValue_OpLOONG64NORconst(v)
case ssaop.OpLOONG64OR:
- return rewriteValueLOONG64_OpLOONG64OR(v)
+ return rewriteValue_OpLOONG64OR(v)
case ssaop.OpLOONG64ORN:
- return rewriteValueLOONG64_OpLOONG64ORN(v)
+ return rewriteValue_OpLOONG64ORN(v)
case ssaop.OpLOONG64ORconst:
- return rewriteValueLOONG64_OpLOONG64ORconst(v)
+ return rewriteValue_OpLOONG64ORconst(v)
case ssaop.OpLOONG64REMV:
- return rewriteValueLOONG64_OpLOONG64REMV(v)
+ return rewriteValue_OpLOONG64REMV(v)
case ssaop.OpLOONG64REMVU:
- return rewriteValueLOONG64_OpLOONG64REMVU(v)
+ return rewriteValue_OpLOONG64REMVU(v)
case ssaop.OpLOONG64ROTR:
- return rewriteValueLOONG64_OpLOONG64ROTR(v)
+ return rewriteValue_OpLOONG64ROTR(v)
case ssaop.OpLOONG64ROTRV:
- return rewriteValueLOONG64_OpLOONG64ROTRV(v)
+ return rewriteValue_OpLOONG64ROTRV(v)
case ssaop.OpLOONG64SGT:
- return rewriteValueLOONG64_OpLOONG64SGT(v)
+ return rewriteValue_OpLOONG64SGT(v)
case ssaop.OpLOONG64SGTU:
- return rewriteValueLOONG64_OpLOONG64SGTU(v)
+ return rewriteValue_OpLOONG64SGTU(v)
case ssaop.OpLOONG64SGTUconst:
- return rewriteValueLOONG64_OpLOONG64SGTUconst(v)
+ return rewriteValue_OpLOONG64SGTUconst(v)
case ssaop.OpLOONG64SGTconst:
- return rewriteValueLOONG64_OpLOONG64SGTconst(v)
+ return rewriteValue_OpLOONG64SGTconst(v)
case ssaop.OpLOONG64SLL:
- return rewriteValueLOONG64_OpLOONG64SLL(v)
+ return rewriteValue_OpLOONG64SLL(v)
case ssaop.OpLOONG64SLLV:
- return rewriteValueLOONG64_OpLOONG64SLLV(v)
+ return rewriteValue_OpLOONG64SLLV(v)
case ssaop.OpLOONG64SLLVconst:
- return rewriteValueLOONG64_OpLOONG64SLLVconst(v)
+ return rewriteValue_OpLOONG64SLLVconst(v)
case ssaop.OpLOONG64SLLconst:
- return rewriteValueLOONG64_OpLOONG64SLLconst(v)
+ return rewriteValue_OpLOONG64SLLconst(v)
case ssaop.OpLOONG64SRA:
- return rewriteValueLOONG64_OpLOONG64SRA(v)
+ return rewriteValue_OpLOONG64SRA(v)
case ssaop.OpLOONG64SRAV:
- return rewriteValueLOONG64_OpLOONG64SRAV(v)
+ return rewriteValue_OpLOONG64SRAV(v)
case ssaop.OpLOONG64SRAVconst:
- return rewriteValueLOONG64_OpLOONG64SRAVconst(v)
+ return rewriteValue_OpLOONG64SRAVconst(v)
case ssaop.OpLOONG64SRL:
- return rewriteValueLOONG64_OpLOONG64SRL(v)
+ return rewriteValue_OpLOONG64SRL(v)
case ssaop.OpLOONG64SRLV:
- return rewriteValueLOONG64_OpLOONG64SRLV(v)
+ return rewriteValue_OpLOONG64SRLV(v)
case ssaop.OpLOONG64SRLVconst:
- return rewriteValueLOONG64_OpLOONG64SRLVconst(v)
+ return rewriteValue_OpLOONG64SRLVconst(v)
case ssaop.OpLOONG64SUBD:
- return rewriteValueLOONG64_OpLOONG64SUBD(v)
+ return rewriteValue_OpLOONG64SUBD(v)
case ssaop.OpLOONG64SUBF:
- return rewriteValueLOONG64_OpLOONG64SUBF(v)
+ return rewriteValue_OpLOONG64SUBF(v)
case ssaop.OpLOONG64SUBV:
- return rewriteValueLOONG64_OpLOONG64SUBV(v)
+ return rewriteValue_OpLOONG64SUBV(v)
case ssaop.OpLOONG64SUBVconst:
- return rewriteValueLOONG64_OpLOONG64SUBVconst(v)
+ return rewriteValue_OpLOONG64SUBVconst(v)
case ssaop.OpLOONG64XOR:
- return rewriteValueLOONG64_OpLOONG64XOR(v)
+ return rewriteValue_OpLOONG64XOR(v)
case ssaop.OpLOONG64XORconst:
- return rewriteValueLOONG64_OpLOONG64XORconst(v)
+ return rewriteValue_OpLOONG64XORconst(v)
case ssaop.OpLeq16:
- return rewriteValueLOONG64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueLOONG64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueLOONG64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueLOONG64_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueLOONG64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueLOONG64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValueLOONG64_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValueLOONG64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueLOONG64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueLOONG64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueLOONG64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueLOONG64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueLOONG64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueLOONG64_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueLOONG64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValueLOONG64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValueLOONG64_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValueLOONG64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValueLOONG64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueLOONG64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueLOONG64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueLOONG64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueLOONG64_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueLOONG64_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueLOONG64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueLOONG64_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueLOONG64_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueLOONG64_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueLOONG64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueLOONG64_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueLOONG64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueLOONG64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueLOONG64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueLOONG64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueLOONG64_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueLOONG64_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueLOONG64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueLOONG64_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMax32F:
v.Op = ssaop.OpLOONG64FMAXF
return true
@@ -582,24 +582,24 @@
v.Op = ssaop.OpLOONG64FMIND
return true
case ssaop.OpMod16:
- return rewriteValueLOONG64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueLOONG64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueLOONG64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueLOONG64_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValueLOONG64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
v.Op = ssaop.OpLOONG64REMVU
return true
case ssaop.OpMod8:
- return rewriteValueLOONG64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueLOONG64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueLOONG64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpLOONG64MULV
return true
@@ -637,29 +637,29 @@
v.Op = ssaop.OpLOONG64NEGV
return true
case ssaop.OpNeq16:
- return rewriteValueLOONG64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueLOONG64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueLOONG64_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValueLOONG64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValueLOONG64_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueLOONG64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpLOONG64XOR
return true
case ssaop.OpNeqPtr:
- return rewriteValueLOONG64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpLOONG64LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueLOONG64_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValueLOONG64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpLOONG64OR
return true
@@ -679,26 +679,26 @@
v.Op = ssaop.OpLOONG64LoweredPanicBoundsRR
return true
case ssaop.OpPopCount16:
- return rewriteValueLOONG64_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValueLOONG64_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
- return rewriteValueLOONG64_OpPopCount64(v)
+ return rewriteValue_OpPopCount64(v)
case ssaop.OpPrefetchCache:
- return rewriteValueLOONG64_OpPrefetchCache(v)
+ return rewriteValue_OpPrefetchCache(v)
case ssaop.OpPrefetchCacheStreamed:
- return rewriteValueLOONG64_OpPrefetchCacheStreamed(v)
+ return rewriteValue_OpPrefetchCacheStreamed(v)
case ssaop.OpPubBarrier:
v.Op = ssaop.OpLOONG64LoweredPubBarrier
return true
case ssaop.OpRotateLeft16:
- return rewriteValueLOONG64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValueLOONG64_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValueLOONG64_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValueLOONG64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpLOONG64LoweredRound32F
return true
@@ -709,75 +709,75 @@
v.Op = ssaop.OpLOONG64FRINTND
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueLOONG64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueLOONG64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueLOONG64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueLOONG64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueLOONG64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueLOONG64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueLOONG64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueLOONG64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueLOONG64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueLOONG64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueLOONG64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueLOONG64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueLOONG64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueLOONG64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueLOONG64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueLOONG64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueLOONG64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueLOONG64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueLOONG64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueLOONG64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueLOONG64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueLOONG64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueLOONG64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueLOONG64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueLOONG64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueLOONG64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueLOONG64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueLOONG64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueLOONG64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueLOONG64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueLOONG64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueLOONG64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueLOONG64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueLOONG64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSelectN:
- return rewriteValueLOONG64_OpSelectN(v)
+ return rewriteValue_OpSelectN(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpLOONG64MOVHreg
return true
@@ -797,7 +797,7 @@
v.Op = ssaop.OpLOONG64MOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValueLOONG64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpLOONG64SQRTD
return true
@@ -808,7 +808,7 @@
v.Op = ssaop.OpLOONG64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValueLOONG64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpLOONG64SUBV
return true
@@ -873,7 +873,7 @@
v.Op = ssaop.OpLOONG64XOR
return true
case ssaop.OpZero:
- return rewriteValueLOONG64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpLOONG64MOVHUreg
return true
@@ -895,7 +895,7 @@
}
return false
}
-func rewriteValueLOONG64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVVaddr {sym} base)
@@ -908,7 +908,7 @@
return true
}
}
-func rewriteValueLOONG64_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -945,7 +945,7 @@
return true
}
}
-func rewriteValueLOONG64_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -966,7 +966,7 @@
return true
}
}
-func rewriteValueLOONG64_OpAtomicCompareAndSwap32Variant(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32Variant(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -987,7 +987,7 @@
return true
}
}
-func rewriteValueLOONG64_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1018,7 +1018,7 @@
return true
}
}
-func rewriteValueLOONG64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1038,7 +1038,7 @@
return true
}
}
-func rewriteValueLOONG64_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1053,7 +1053,7 @@
return true
}
}
-func rewriteValueLOONG64_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BitLen32 <t> x)
@@ -1072,7 +1072,7 @@
return true
}
}
-func rewriteValueLOONG64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BitLen64 <t> x)
@@ -1091,7 +1091,7 @@
return true
}
}
-func rewriteValueLOONG64_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1106,7 +1106,7 @@
return true
}
}
-func rewriteValueLOONG64_OpBitRev16(v *ssa.Value) bool {
+func rewriteValue_OpBitRev16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BitRev16 <t> x)
@@ -1121,7 +1121,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1136,7 +1136,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1151,7 +1151,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1166,7 +1166,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1181,7 +1181,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1202,7 +1202,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1212,7 +1212,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1222,7 +1222,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst32F(v *ssa.Value) bool {
+func rewriteValue_OpConst32F(v *ssa.Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [float64(val)])
for {
@@ -1232,7 +1232,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1242,7 +1242,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst64F(v *ssa.Value) bool {
+func rewriteValue_OpConst64F(v *ssa.Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [float64(val)])
for {
@@ -1252,7 +1252,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1262,7 +1262,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVVconst [int64(ssa.B2i(t))])
for {
@@ -1272,7 +1272,7 @@
return true
}
}
-func rewriteValueLOONG64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVVconst [0])
for {
@@ -1281,7 +1281,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1298,7 +1298,7 @@
return true
}
}
-func rewriteValueLOONG64_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1315,7 +1315,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1334,7 +1334,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1353,7 +1353,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1372,7 +1372,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1391,7 +1391,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1404,7 +1404,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1423,7 +1423,7 @@
return true
}
}
-func rewriteValueLOONG64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1442,7 +1442,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1465,7 +1465,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1488,7 +1488,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1504,7 +1504,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1523,7 +1523,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1539,7 +1539,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1562,7 +1562,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1581,7 +1581,7 @@
return true
}
}
-func rewriteValueLOONG64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1600,7 +1600,7 @@
return true
}
}
-func rewriteValueLOONG64_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -1613,7 +1613,7 @@
return true
}
}
-func rewriteValueLOONG64_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1628,7 +1628,7 @@
return true
}
}
-func rewriteValueLOONG64_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1647,7 +1647,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLOONG64ADDD(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ADDD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDD (MULD x y) z)
@@ -1696,7 +1696,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ADDF(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ADDF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDF (MULF x y) z)
@@ -1745,7 +1745,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ADDV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ADDV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1950,7 +1950,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ADDVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ADDVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
// cond: ssa.Is32Bit(off1+int64(off2))
@@ -2046,7 +2046,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ADDshiftLLV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ADDshiftLLV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDshiftLLV x (MOVVconst [c]) [d])
@@ -2069,7 +2069,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64AND(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVVconst [c]))
@@ -2119,7 +2119,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVVconst [0])
@@ -2169,7 +2169,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64DIVV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64DIVV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVV (MOVVconst [c]) (MOVVconst [d]))
@@ -2193,7 +2193,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64DIVVU(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64DIVVU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVVU x (MOVVconst [1]))
@@ -2244,7 +2244,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVVconst [c]) mem)
@@ -2265,7 +2265,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVVconst [c]) mem)
@@ -2286,7 +2286,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2324,7 +2324,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MASKEQZ(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MASKEQZ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MASKEQZ (MOVVconst [0]) cond)
@@ -2369,7 +2369,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MASKNEZ(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MASKNEZ(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MASKNEZ (MOVVconst [0]) cond)
// result: (MOVVconst [0])
@@ -2383,7 +2383,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2506,7 +2506,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2548,7 +2548,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg (SRLVconst [rc] x))
// cond: rc < 8
@@ -2729,7 +2729,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2852,7 +2852,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2894,7 +2894,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -2957,7 +2957,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3157,7 +3157,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVBstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -3202,7 +3202,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVDF(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVDF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDF (ABSD (MOVFD x)))
// result: (ABSF x)
@@ -3236,7 +3236,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVDload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3346,7 +3346,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVDloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVDloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3388,7 +3388,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3503,7 +3503,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVDstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVDstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -3548,7 +3548,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVFload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVFload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3658,7 +3658,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVFloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVFloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3700,7 +3700,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVFstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVFstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3815,7 +3815,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVFstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVFstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -3860,7 +3860,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3983,7 +3983,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4025,7 +4025,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg (SRLVconst [rc] x))
// cond: rc < 16
@@ -4168,7 +4168,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4291,7 +4291,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4333,7 +4333,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -4462,7 +4462,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4628,7 +4628,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVHstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -4673,7 +4673,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4813,7 +4813,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4855,7 +4855,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVnop(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVVnop (MOVVconst [c]))
// result: (MOVVconst [c])
@@ -4870,7 +4870,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVVreg x)
// cond: x.Uses == 1
@@ -4897,7 +4897,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5012,7 +5012,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVVstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -5057,7 +5057,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWUload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5199,7 +5199,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWUloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWUloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5241,7 +5241,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg (SRLVconst [rc] x))
// cond: rc < 32
@@ -5412,7 +5412,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5535,7 +5535,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWloadidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5577,7 +5577,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -5761,7 +5761,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5910,7 +5910,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MOVWstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -5955,7 +5955,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64MULV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MULV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6072,7 +6072,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64NEGV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64NEGV(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (NEGV (SUBV x y))
@@ -6158,7 +6158,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64NOR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64NOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NOR x (MOVVconst [c]))
@@ -6183,7 +6183,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64NORconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64NORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NORconst [c] (MOVVconst [d]))
// result: (MOVVconst [^(c|d)])
@@ -6199,7 +6199,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64OR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6391,7 +6391,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ORN(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ORN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x (MOVVconst [-1]))
@@ -6406,7 +6406,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ORconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -6460,7 +6460,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64REMV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64REMV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (REMV (MOVVconst [c]) (MOVVconst [d]))
@@ -6484,7 +6484,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64REMVU(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64REMVU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (REMVU _ (MOVVconst [1]))
@@ -6535,7 +6535,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ROTR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ROTR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTR x (MOVVconst [c]))
@@ -6553,7 +6553,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64ROTRV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64ROTRV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTRV x (MOVVconst [c]))
@@ -6571,7 +6571,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SGT(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SGT(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6632,7 +6632,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SGTU(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SGTU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGTU (MOVVconst [c]) x)
@@ -6665,7 +6665,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SGTUconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SGTUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTUconst [c] (MOVVconst [d]))
// cond: uint64(c)>uint64(d)
@@ -6757,7 +6757,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SGTconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SGTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTconst [c] (MOVVconst [d]))
// cond: c>d
@@ -6933,7 +6933,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SLL(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL _ (MOVVconst [c]))
@@ -6982,7 +6982,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SLLV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SLLV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLLV _ (MOVVconst [c]))
@@ -7027,7 +7027,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SLLVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SLLVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLVconst <t> [c] (ADDV x x))
// cond: c < t.Size() * 8 - 1
@@ -7078,7 +7078,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SLLconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLconst <t> [c] (ADDV x x))
// cond: c < t.Size() * 8 - 1
@@ -7117,7 +7117,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRA(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVVconst [c]))
@@ -7168,7 +7168,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRAV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRAV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAV x (MOVVconst [c]))
@@ -7215,7 +7215,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRAVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRAVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SRAVconst [rc] (MOVWreg y))
@@ -7308,7 +7308,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRL(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL _ (MOVVconst [c]))
@@ -7357,7 +7357,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRLV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRLV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRLV _ (MOVVconst [c]))
@@ -7402,7 +7402,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SRLVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SRLVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLVconst [rc] (SLLVconst [lc] x))
// cond: lc <= rc
@@ -7549,7 +7549,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SUBD(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SUBD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBD (MULD x y) z)
@@ -7630,7 +7630,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SUBF(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SUBF(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBF (MULF x y) z)
@@ -7711,7 +7711,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SUBV(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SUBV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBV x (MOVVconst [c]))
@@ -7788,7 +7788,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64SUBVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SUBVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBVconst [0] x)
// result: x
@@ -7850,7 +7850,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64XOR(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8028,7 +8028,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLOONG64XORconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -8084,7 +8084,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8107,7 +8107,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8130,7 +8130,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8153,7 +8153,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8169,7 +8169,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8192,7 +8192,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8211,7 +8211,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8227,7 +8227,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8246,7 +8246,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8269,7 +8269,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8292,7 +8292,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8311,7 +8311,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8330,7 +8330,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8349,7 +8349,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8365,7 +8365,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8384,7 +8384,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 x y)
@@ -8397,7 +8397,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8413,7 +8413,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U x y)
@@ -8426,7 +8426,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8445,7 +8445,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8464,7 +8464,7 @@
return true
}
}
-func rewriteValueLOONG64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -8609,7 +8609,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8649,7 +8649,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8691,7 +8691,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8733,7 +8733,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8773,7 +8773,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8815,7 +8815,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8857,7 +8857,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8899,7 +8899,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8939,7 +8939,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8981,7 +8981,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9023,7 +9023,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9065,7 +9065,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9105,7 +9105,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9147,7 +9147,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9189,7 +9189,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9231,7 +9231,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9271,7 +9271,7 @@
}
return false
}
-func rewriteValueLOONG64_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9313,7 +9313,7 @@
}
return false
}
-func rewriteValueLOONG64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9332,7 +9332,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9351,7 +9351,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9370,7 +9370,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9389,7 +9389,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -9402,7 +9402,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9421,7 +9421,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9440,7 +9440,7 @@
return true
}
}
-func rewriteValueLOONG64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9802,7 +9802,7 @@
}
return false
}
-func rewriteValueLOONG64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9825,7 +9825,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9848,7 +9848,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9864,7 +9864,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9883,7 +9883,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9899,7 +9899,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9922,7 +9922,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9941,7 +9941,7 @@
return true
}
}
-func rewriteValueLOONG64_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -9953,7 +9953,7 @@
return true
}
}
-func rewriteValueLOONG64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVVaddr [int32(off)] ptr)
@@ -9979,7 +9979,7 @@
return true
}
}
-func rewriteValueLOONG64_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10000,7 +10000,7 @@
return true
}
}
-func rewriteValueLOONG64_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10019,7 +10019,7 @@
return true
}
}
-func rewriteValueLOONG64_OpPopCount64(v *ssa.Value) bool {
+func rewriteValue_OpPopCount64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10038,7 +10038,7 @@
return true
}
}
-func rewriteValueLOONG64_OpPrefetchCache(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCache(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCache addr mem)
@@ -10052,7 +10052,7 @@
return true
}
}
-func rewriteValueLOONG64_OpPrefetchCacheStreamed(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCacheStreamed(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCacheStreamed addr mem)
@@ -10066,7 +10066,7 @@
return true
}
}
-func rewriteValueLOONG64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10113,7 +10113,7 @@
return true
}
}
-func rewriteValueLOONG64_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10129,7 +10129,7 @@
return true
}
}
-func rewriteValueLOONG64_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10145,7 +10145,7 @@
return true
}
}
-func rewriteValueLOONG64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10197,7 +10197,7 @@
return true
}
}
-func rewriteValueLOONG64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10243,7 +10243,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10289,7 +10289,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10333,7 +10333,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10379,7 +10379,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10427,7 +10427,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10475,7 +10475,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10521,7 +10521,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10569,7 +10569,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10611,7 +10611,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10653,7 +10653,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10693,7 +10693,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10735,7 +10735,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10779,7 +10779,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10823,7 +10823,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10865,7 +10865,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10909,7 +10909,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10951,7 +10951,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10993,7 +10993,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11033,7 +11033,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11075,7 +11075,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11119,7 +11119,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11163,7 +11163,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11205,7 +11205,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11249,7 +11249,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11295,7 +11295,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11341,7 +11341,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11385,7 +11385,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11431,7 +11431,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11479,7 +11479,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11527,7 +11527,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11573,7 +11573,7 @@
}
return false
}
-func rewriteValueLOONG64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11621,7 +11621,7 @@
}
return false
}
-func rewriteValueLOONG64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Select0 (Mul64uhilo x y))
@@ -11682,7 +11682,7 @@
}
return false
}
-func rewriteValueLOONG64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11761,7 +11761,7 @@
}
return false
}
-func rewriteValueLOONG64_OpSelectN(v *ssa.Value) bool {
+func rewriteValue_OpSelectN(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -11795,7 +11795,7 @@
}
return false
}
-func rewriteValueLOONG64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -11811,7 +11811,7 @@
return true
}
}
-func rewriteValueLOONG64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11907,7 +11907,7 @@
}
return false
}
-func rewriteValueLOONG64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12214,7 +12214,7 @@
}
return false
}
-func rewriteBlockLOONG64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockLOONG64BEQ:
diff --git a/src/cmd/compile/internal/ssacompile/rewriteLOONG64latelower.go b/src/cmd/compile/internal/ssarewrite/rewriteloong64latelower/rewriteLOONG64latelower.go
similarity index 73%
rename from src/cmd/compile/internal/ssacompile/rewriteLOONG64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewriteloong64latelower/rewriteLOONG64latelower.go
index 7706cc7..dfb6ed0 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteLOONG64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteloong64latelower/rewriteLOONG64latelower.go
@@ -1,27 +1,27 @@
// Code generated from _gen/LOONG64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteloong64latelower
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueLOONG64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpLOONG64MOVBUreg:
- return rewriteValueLOONG64latelower_OpLOONG64MOVBUreg(v)
+ return rewriteValue_OpLOONG64MOVBUreg(v)
case ssaop.OpLOONG64MOVHUreg:
- return rewriteValueLOONG64latelower_OpLOONG64MOVHUreg(v)
+ return rewriteValue_OpLOONG64MOVHUreg(v)
case ssaop.OpLOONG64MOVVconst:
- return rewriteValueLOONG64latelower_OpLOONG64MOVVconst(v)
+ return rewriteValue_OpLOONG64MOVVconst(v)
case ssaop.OpLOONG64MOVWUreg:
- return rewriteValueLOONG64latelower_OpLOONG64MOVWUreg(v)
+ return rewriteValue_OpLOONG64MOVWUreg(v)
case ssaop.OpLOONG64SLLVconst:
- return rewriteValueLOONG64latelower_OpLOONG64SLLVconst(v)
+ return rewriteValue_OpLOONG64SLLVconst(v)
}
return false
}
-func rewriteValueLOONG64latelower_OpLOONG64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x)
// cond: ssa.ZeroUpper56Bits(x)
@@ -36,7 +36,7 @@
}
return false
}
-func rewriteValueLOONG64latelower_OpLOONG64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x)
// cond: ssa.ZeroUpper48Bits(x)
@@ -51,7 +51,7 @@
}
return false
}
-func rewriteValueLOONG64latelower_OpLOONG64MOVVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVVconst(v *ssa.Value) bool {
// match: (MOVVconst [0])
// result: (ZERO)
for {
@@ -63,7 +63,7 @@
}
return false
}
-func rewriteValueLOONG64latelower_OpLOONG64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg x)
// cond: ssa.ZeroUpper32Bits(x)
@@ -78,7 +78,7 @@
}
return false
}
-func rewriteValueLOONG64latelower_OpLOONG64SLLVconst(v *ssa.Value) bool {
+func rewriteValue_OpLOONG64SLLVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLVconst [1] x)
// result: (ADDV x x)
@@ -93,7 +93,7 @@
}
return false
}
-func rewriteBlockLOONG64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.BlockLOONG64EQZ:
// match: (EQZ (XOR x y) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/rewriteMIPS.go b/src/cmd/compile/internal/ssarewrite/rewritemips/rewriteMIPS.go
similarity index 91%
rename from src/cmd/compile/internal/ssacompile/rewriteMIPS.go
rename to src/cmd/compile/internal/ssarewrite/rewritemips/rewriteMIPS.go
index a1114a3..c05c850 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritemips/rewriteMIPS.go
@@ -1,13 +1,13 @@
// Code generated from _gen/MIPS.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritemips
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueMIPS(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpMIPSABSD
@@ -22,7 +22,7 @@
v.Op = ssaop.OpMIPSADDF
return true
case ssaop.OpAdd32withcarry:
- return rewriteValueMIPS_OpAdd32withcarry(v)
+ return rewriteValue_OpAdd32withcarry(v)
case ssaop.OpAdd64F:
v.Op = ssaop.OpMIPSADDD
return true
@@ -33,7 +33,7 @@
v.Op = ssaop.OpMIPSADD
return true
case ssaop.OpAddr:
- return rewriteValueMIPS_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpMIPSAND
return true
@@ -53,7 +53,7 @@
v.Op = ssaop.OpMIPSLoweredAtomicAnd
return true
case ssaop.OpAtomicAnd8:
- return rewriteValueMIPS_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
v.Op = ssaop.OpMIPSLoweredAtomicCas
return true
@@ -73,7 +73,7 @@
v.Op = ssaop.OpMIPSLoweredAtomicOr
return true
case ssaop.OpAtomicOr8:
- return rewriteValueMIPS_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
v.Op = ssaop.OpMIPSLoweredAtomicStore32
return true
@@ -84,26 +84,26 @@
v.Op = ssaop.OpMIPSLoweredAtomicStore32
return true
case ssaop.OpAvg32u:
- return rewriteValueMIPS_OpAvg32u(v)
+ return rewriteValue_OpAvg32u(v)
case ssaop.OpBitLen16:
- return rewriteValueMIPS_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueMIPS_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen8:
- return rewriteValueMIPS_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpClosureCall:
v.Op = ssaop.OpMIPSCALLclosure
return true
case ssaop.OpCom16:
- return rewriteValueMIPS_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValueMIPS_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom8:
- return rewriteValueMIPS_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpConst16:
- return rewriteValueMIPS_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueMIPS_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
v.Op = ssaop.OpMIPSMOVFconst
return true
@@ -111,23 +111,23 @@
v.Op = ssaop.OpMIPSMOVDconst
return true
case ssaop.OpConst8:
- return rewriteValueMIPS_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueMIPS_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueMIPS_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCtz16:
- return rewriteValueMIPS_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz32:
- return rewriteValueMIPS_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpCtz32
return true
case ssaop.OpCtz8:
- return rewriteValueMIPS_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz32
return true
@@ -153,37 +153,37 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueMIPS_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueMIPS_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueMIPS_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpMIPSDIVF
return true
case ssaop.OpDiv32u:
- return rewriteValueMIPS_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpMIPSDIVD
return true
case ssaop.OpDiv8:
- return rewriteValueMIPS_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueMIPS_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueMIPS_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueMIPS_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueMIPS_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64F:
- return rewriteValueMIPS_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueMIPS_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueMIPS_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueMIPS_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpGetCallerPC:
v.Op = ssaop.OpMIPSLoweredGetCallerPC
return true
@@ -194,198 +194,198 @@
v.Op = ssaop.OpMIPSLoweredGetClosurePtr
return true
case ssaop.OpHmul32:
- return rewriteValueMIPS_OpHmul32(v)
+ return rewriteValue_OpHmul32(v)
case ssaop.OpHmul32u:
- return rewriteValueMIPS_OpHmul32u(v)
+ return rewriteValue_OpHmul32u(v)
case ssaop.OpInterCall:
v.Op = ssaop.OpMIPSCALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValueMIPS_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueMIPS_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueMIPS_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValueMIPS_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueMIPS_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueMIPS_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueMIPS_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueMIPS_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64F:
- return rewriteValueMIPS_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq8:
- return rewriteValueMIPS_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueMIPS_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueMIPS_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueMIPS_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueMIPS_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueMIPS_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueMIPS_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64F:
- return rewriteValueMIPS_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess8:
- return rewriteValueMIPS_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueMIPS_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueMIPS_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueMIPS_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueMIPS_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueMIPS_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueMIPS_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueMIPS_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueMIPS_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueMIPS_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueMIPS_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueMIPS_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueMIPS_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueMIPS_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueMIPS_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueMIPS_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMIPSADD:
- return rewriteValueMIPS_OpMIPSADD(v)
+ return rewriteValue_OpMIPSADD(v)
case ssaop.OpMIPSADDconst:
- return rewriteValueMIPS_OpMIPSADDconst(v)
+ return rewriteValue_OpMIPSADDconst(v)
case ssaop.OpMIPSAND:
- return rewriteValueMIPS_OpMIPSAND(v)
+ return rewriteValue_OpMIPSAND(v)
case ssaop.OpMIPSANDconst:
- return rewriteValueMIPS_OpMIPSANDconst(v)
+ return rewriteValue_OpMIPSANDconst(v)
case ssaop.OpMIPSCMOVZ:
- return rewriteValueMIPS_OpMIPSCMOVZ(v)
+ return rewriteValue_OpMIPSCMOVZ(v)
case ssaop.OpMIPSCMOVZzero:
- return rewriteValueMIPS_OpMIPSCMOVZzero(v)
+ return rewriteValue_OpMIPSCMOVZzero(v)
case ssaop.OpMIPSLoweredAtomicAdd:
- return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
+ return rewriteValue_OpMIPSLoweredAtomicAdd(v)
case ssaop.OpMIPSLoweredAtomicStore32:
- return rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v)
+ return rewriteValue_OpMIPSLoweredAtomicStore32(v)
case ssaop.OpMIPSLoweredPanicBoundsRC:
- return rewriteValueMIPS_OpMIPSLoweredPanicBoundsRC(v)
+ return rewriteValue_OpMIPSLoweredPanicBoundsRC(v)
case ssaop.OpMIPSLoweredPanicBoundsRR:
- return rewriteValueMIPS_OpMIPSLoweredPanicBoundsRR(v)
+ return rewriteValue_OpMIPSLoweredPanicBoundsRR(v)
case ssaop.OpMIPSLoweredPanicExtendRC:
- return rewriteValueMIPS_OpMIPSLoweredPanicExtendRC(v)
+ return rewriteValue_OpMIPSLoweredPanicExtendRC(v)
case ssaop.OpMIPSLoweredPanicExtendRR:
- return rewriteValueMIPS_OpMIPSLoweredPanicExtendRR(v)
+ return rewriteValue_OpMIPSLoweredPanicExtendRR(v)
case ssaop.OpMIPSMOVBUload:
- return rewriteValueMIPS_OpMIPSMOVBUload(v)
+ return rewriteValue_OpMIPSMOVBUload(v)
case ssaop.OpMIPSMOVBUreg:
- return rewriteValueMIPS_OpMIPSMOVBUreg(v)
+ return rewriteValue_OpMIPSMOVBUreg(v)
case ssaop.OpMIPSMOVBload:
- return rewriteValueMIPS_OpMIPSMOVBload(v)
+ return rewriteValue_OpMIPSMOVBload(v)
case ssaop.OpMIPSMOVBreg:
- return rewriteValueMIPS_OpMIPSMOVBreg(v)
+ return rewriteValue_OpMIPSMOVBreg(v)
case ssaop.OpMIPSMOVBstore:
- return rewriteValueMIPS_OpMIPSMOVBstore(v)
+ return rewriteValue_OpMIPSMOVBstore(v)
case ssaop.OpMIPSMOVBstorezero:
- return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
+ return rewriteValue_OpMIPSMOVBstorezero(v)
case ssaop.OpMIPSMOVDload:
- return rewriteValueMIPS_OpMIPSMOVDload(v)
+ return rewriteValue_OpMIPSMOVDload(v)
case ssaop.OpMIPSMOVDstore:
- return rewriteValueMIPS_OpMIPSMOVDstore(v)
+ return rewriteValue_OpMIPSMOVDstore(v)
case ssaop.OpMIPSMOVFload:
- return rewriteValueMIPS_OpMIPSMOVFload(v)
+ return rewriteValue_OpMIPSMOVFload(v)
case ssaop.OpMIPSMOVFstore:
- return rewriteValueMIPS_OpMIPSMOVFstore(v)
+ return rewriteValue_OpMIPSMOVFstore(v)
case ssaop.OpMIPSMOVHUload:
- return rewriteValueMIPS_OpMIPSMOVHUload(v)
+ return rewriteValue_OpMIPSMOVHUload(v)
case ssaop.OpMIPSMOVHUreg:
- return rewriteValueMIPS_OpMIPSMOVHUreg(v)
+ return rewriteValue_OpMIPSMOVHUreg(v)
case ssaop.OpMIPSMOVHload:
- return rewriteValueMIPS_OpMIPSMOVHload(v)
+ return rewriteValue_OpMIPSMOVHload(v)
case ssaop.OpMIPSMOVHreg:
- return rewriteValueMIPS_OpMIPSMOVHreg(v)
+ return rewriteValue_OpMIPSMOVHreg(v)
case ssaop.OpMIPSMOVHstore:
- return rewriteValueMIPS_OpMIPSMOVHstore(v)
+ return rewriteValue_OpMIPSMOVHstore(v)
case ssaop.OpMIPSMOVHstorezero:
- return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
+ return rewriteValue_OpMIPSMOVHstorezero(v)
case ssaop.OpMIPSMOVWload:
- return rewriteValueMIPS_OpMIPSMOVWload(v)
+ return rewriteValue_OpMIPSMOVWload(v)
case ssaop.OpMIPSMOVWnop:
- return rewriteValueMIPS_OpMIPSMOVWnop(v)
+ return rewriteValue_OpMIPSMOVWnop(v)
case ssaop.OpMIPSMOVWreg:
- return rewriteValueMIPS_OpMIPSMOVWreg(v)
+ return rewriteValue_OpMIPSMOVWreg(v)
case ssaop.OpMIPSMOVWstore:
- return rewriteValueMIPS_OpMIPSMOVWstore(v)
+ return rewriteValue_OpMIPSMOVWstore(v)
case ssaop.OpMIPSMOVWstorezero:
- return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
+ return rewriteValue_OpMIPSMOVWstorezero(v)
case ssaop.OpMIPSMUL:
- return rewriteValueMIPS_OpMIPSMUL(v)
+ return rewriteValue_OpMIPSMUL(v)
case ssaop.OpMIPSNEG:
- return rewriteValueMIPS_OpMIPSNEG(v)
+ return rewriteValue_OpMIPSNEG(v)
case ssaop.OpMIPSOR:
- return rewriteValueMIPS_OpMIPSOR(v)
+ return rewriteValue_OpMIPSOR(v)
case ssaop.OpMIPSORconst:
- return rewriteValueMIPS_OpMIPSORconst(v)
+ return rewriteValue_OpMIPSORconst(v)
case ssaop.OpMIPSSGT:
- return rewriteValueMIPS_OpMIPSSGT(v)
+ return rewriteValue_OpMIPSSGT(v)
case ssaop.OpMIPSSGTU:
- return rewriteValueMIPS_OpMIPSSGTU(v)
+ return rewriteValue_OpMIPSSGTU(v)
case ssaop.OpMIPSSGTUconst:
- return rewriteValueMIPS_OpMIPSSGTUconst(v)
+ return rewriteValue_OpMIPSSGTUconst(v)
case ssaop.OpMIPSSGTUzero:
- return rewriteValueMIPS_OpMIPSSGTUzero(v)
+ return rewriteValue_OpMIPSSGTUzero(v)
case ssaop.OpMIPSSGTconst:
- return rewriteValueMIPS_OpMIPSSGTconst(v)
+ return rewriteValue_OpMIPSSGTconst(v)
case ssaop.OpMIPSSGTzero:
- return rewriteValueMIPS_OpMIPSSGTzero(v)
+ return rewriteValue_OpMIPSSGTzero(v)
case ssaop.OpMIPSSLL:
- return rewriteValueMIPS_OpMIPSSLL(v)
+ return rewriteValue_OpMIPSSLL(v)
case ssaop.OpMIPSSLLconst:
- return rewriteValueMIPS_OpMIPSSLLconst(v)
+ return rewriteValue_OpMIPSSLLconst(v)
case ssaop.OpMIPSSRA:
- return rewriteValueMIPS_OpMIPSSRA(v)
+ return rewriteValue_OpMIPSSRA(v)
case ssaop.OpMIPSSRAconst:
- return rewriteValueMIPS_OpMIPSSRAconst(v)
+ return rewriteValue_OpMIPSSRAconst(v)
case ssaop.OpMIPSSRL:
- return rewriteValueMIPS_OpMIPSSRL(v)
+ return rewriteValue_OpMIPSSRL(v)
case ssaop.OpMIPSSRLconst:
- return rewriteValueMIPS_OpMIPSSRLconst(v)
+ return rewriteValue_OpMIPSSRLconst(v)
case ssaop.OpMIPSSUB:
- return rewriteValueMIPS_OpMIPSSUB(v)
+ return rewriteValue_OpMIPSSUB(v)
case ssaop.OpMIPSSUBconst:
- return rewriteValueMIPS_OpMIPSSUBconst(v)
+ return rewriteValue_OpMIPSSUBconst(v)
case ssaop.OpMIPSXOR:
- return rewriteValueMIPS_OpMIPSXOR(v)
+ return rewriteValue_OpMIPSXOR(v)
case ssaop.OpMIPSXORconst:
- return rewriteValueMIPS_OpMIPSXORconst(v)
+ return rewriteValue_OpMIPSXORconst(v)
case ssaop.OpMod16:
- return rewriteValueMIPS_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueMIPS_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueMIPS_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueMIPS_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod8:
- return rewriteValueMIPS_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueMIPS_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueMIPS_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpMIPSMUL
return true
@@ -420,27 +420,27 @@
v.Op = ssaop.OpMIPSNEG
return true
case ssaop.OpNeq16:
- return rewriteValueMIPS_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueMIPS_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueMIPS_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64F:
- return rewriteValueMIPS_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueMIPS_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpMIPSXOR
return true
case ssaop.OpNeqPtr:
- return rewriteValueMIPS_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpMIPSLoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueMIPS_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValueMIPS_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpMIPSOR
return true
@@ -463,13 +463,13 @@
v.Op = ssaop.OpMIPSLoweredPubBarrier
return true
case ssaop.OpRotateLeft16:
- return rewriteValueMIPS_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValueMIPS_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValueMIPS_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValueMIPS_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpCopy
return true
@@ -477,57 +477,57 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueMIPS_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueMIPS_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueMIPS_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueMIPS_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueMIPS_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueMIPS_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueMIPS_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueMIPS_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueMIPS_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueMIPS_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueMIPS_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueMIPS_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueMIPS_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueMIPS_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueMIPS_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueMIPS_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueMIPS_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueMIPS_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueMIPS_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueMIPS_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueMIPS_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueMIPS_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueMIPS_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueMIPS_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueMIPS_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueMIPS_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpMIPSMOVHreg
return true
@@ -538,9 +538,9 @@
v.Op = ssaop.OpMIPSMOVBreg
return true
case ssaop.OpSignmask:
- return rewriteValueMIPS_OpSignmask(v)
+ return rewriteValue_OpSignmask(v)
case ssaop.OpSlicemask:
- return rewriteValueMIPS_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpMIPSSQRTD
return true
@@ -551,7 +551,7 @@
v.Op = ssaop.OpMIPSCALLstatic
return true
case ssaop.OpStore:
- return rewriteValueMIPS_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpMIPSSUB
return true
@@ -562,7 +562,7 @@
v.Op = ssaop.OpMIPSSUBF
return true
case ssaop.OpSub32withcarry:
- return rewriteValueMIPS_OpSub32withcarry(v)
+ return rewriteValue_OpSub32withcarry(v)
case ssaop.OpSub64F:
v.Op = ssaop.OpMIPSSUBD
return true
@@ -600,7 +600,7 @@
v.Op = ssaop.OpMIPSXOR
return true
case ssaop.OpZero:
- return rewriteValueMIPS_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpMIPSMOVHUreg
return true
@@ -611,11 +611,11 @@
v.Op = ssaop.OpMIPSMOVBUreg
return true
case ssaop.OpZeromask:
- return rewriteValueMIPS_OpZeromask(v)
+ return rewriteValue_OpZeromask(v)
}
return false
}
-func rewriteValueMIPS_OpAdd32withcarry(v *ssa.Value) bool {
+func rewriteValue_OpAdd32withcarry(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -634,7 +634,7 @@
return true
}
}
-func rewriteValueMIPS_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVWaddr {sym} base)
@@ -647,7 +647,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -735,7 +735,7 @@
}
return false
}
-func rewriteValueMIPS_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -803,7 +803,7 @@
}
return false
}
-func rewriteValueMIPS_OpAvg32u(v *ssa.Value) bool {
+func rewriteValue_OpAvg32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -823,7 +823,7 @@
return true
}
}
-func rewriteValueMIPS_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -838,7 +838,7 @@
return true
}
}
-func rewriteValueMIPS_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -856,7 +856,7 @@
return true
}
}
-func rewriteValueMIPS_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -871,7 +871,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -886,7 +886,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -901,7 +901,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -916,7 +916,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -926,7 +926,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -936,7 +936,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVWconst [int32(val)])
for {
@@ -946,7 +946,7 @@
return true
}
}
-func rewriteValueMIPS_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVWconst [ssa.B2i32(t)])
for {
@@ -956,7 +956,7 @@
return true
}
}
-func rewriteValueMIPS_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVWconst [0])
for {
@@ -965,7 +965,7 @@
return true
}
}
-func rewriteValueMIPS_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -982,7 +982,7 @@
return true
}
}
-func rewriteValueMIPS_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1007,7 +1007,7 @@
return true
}
}
-func rewriteValueMIPS_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1024,7 +1024,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1045,7 +1045,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1066,7 +1066,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1083,7 +1083,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1100,7 +1100,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1121,7 +1121,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1142,7 +1142,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1164,7 +1164,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1182,7 +1182,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1198,7 +1198,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1214,7 +1214,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1236,7 +1236,7 @@
return true
}
}
-func rewriteValueMIPS_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1254,7 +1254,7 @@
return true
}
}
-func rewriteValueMIPS_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1272,7 +1272,7 @@
return true
}
}
-func rewriteValueMIPS_OpHmul32(v *ssa.Value) bool {
+func rewriteValue_OpHmul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1289,7 +1289,7 @@
return true
}
}
-func rewriteValueMIPS_OpHmul32u(v *ssa.Value) bool {
+func rewriteValue_OpHmul32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1306,7 +1306,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -1319,7 +1319,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1334,7 +1334,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1352,7 +1352,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1374,7 +1374,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1396,7 +1396,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1414,7 +1414,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1430,7 +1430,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1448,7 +1448,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1464,7 +1464,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1486,7 +1486,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1508,7 +1508,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1527,7 +1527,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1546,7 +1546,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32 x y)
@@ -1559,7 +1559,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1575,7 +1575,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32U x y)
@@ -1588,7 +1588,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1604,7 +1604,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1623,7 +1623,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1642,7 +1642,7 @@
return true
}
}
-func rewriteValueMIPS_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -1759,7 +1759,7 @@
}
return false
}
-func rewriteValueMIPS_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1799,7 +1799,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1824,7 +1824,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1847,7 +1847,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -1884,7 +1884,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1909,7 +1909,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1934,7 +1934,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1957,7 +1957,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -1994,7 +1994,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2019,7 +2019,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2044,7 +2044,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2067,7 +2067,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -2104,7 +2104,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2129,7 +2129,7 @@
return true
}
}
-func rewriteValueMIPS_OpMIPSADD(v *ssa.Value) bool {
+func rewriteValue_OpMIPSADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD x (MOVWconst <t> [c]))
@@ -2170,7 +2170,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSADDconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2240,7 +2240,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSAND(v *ssa.Value) bool {
+func rewriteValue_OpMIPSAND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2293,7 +2293,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSANDconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVWconst [0])
@@ -2343,7 +2343,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZ(v *ssa.Value) bool {
+func rewriteValue_OpMIPSCMOVZ(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2386,7 +2386,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZzero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSCMOVZzero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVZzero _ (MOVWconst [0]))
@@ -2416,7 +2416,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredAtomicAdd(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2440,7 +2440,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredAtomicStore32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2458,7 +2458,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVWconst [c]) mem)
@@ -2479,7 +2479,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2517,7 +2517,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredPanicExtendRC(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredPanicExtendRC(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2543,7 +2543,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredPanicExtendRR(v *ssa.Value) bool {
+func rewriteValue_OpMIPSLoweredPanicExtendRR(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -2587,7 +2587,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off] {sym} ptr (MOVBstore [off] {sym} ptr x _))
@@ -2674,7 +2674,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBUreg x:(MOVBUload _ _))
@@ -2749,7 +2749,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off] {sym} ptr (MOVBstore [off] {sym} ptr x _))
@@ -2836,7 +2836,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBreg x:(MOVBload _ _))
@@ -2915,7 +2915,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3068,7 +3068,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstorezero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVBstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3117,7 +3117,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3186,7 +3186,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3238,7 +3238,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVFload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVFload [off] {sym} ptr (MOVWstore [off] {sym} ptr val _))
@@ -3324,7 +3324,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVFstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3393,7 +3393,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHUload [off] {sym} ptr (MOVHstore [off] {sym} ptr x _))
@@ -3480,7 +3480,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHUreg x:(MOVBUload _ _))
@@ -3577,7 +3577,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off] {sym} ptr (MOVHstore [off] {sym} ptr x _))
@@ -3664,7 +3664,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHreg x:(MOVBload _ _))
@@ -3787,7 +3787,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3906,7 +3906,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstorezero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVHstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3955,7 +3955,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWload(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off] {sym} ptr (MOVFstore [off] {sym} ptr val _))
@@ -4058,7 +4058,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWnop(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVWnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWnop (MOVWconst [c]))
// result: (MOVWconst [c])
@@ -4073,7 +4073,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x)
// cond: x.Uses == 1
@@ -4100,7 +4100,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4202,7 +4202,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstorezero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMOVWstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4251,7 +4251,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMUL(v *ssa.Value) bool {
+func rewriteValue_OpMIPSMUL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MUL (MOVWconst [0]) _ )
@@ -4334,7 +4334,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSNEG(v *ssa.Value) bool {
+func rewriteValue_OpMIPSNEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEG (SUB x y))
// result: (SUB y x)
@@ -4371,7 +4371,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSOR(v *ssa.Value) bool {
+func rewriteValue_OpMIPSOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4423,7 +4423,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSORconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -4473,7 +4473,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGT(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGT(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGT (MOVWconst [c]) x)
@@ -4502,7 +4502,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTU(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGTU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGTU (MOVWconst [c]) x)
@@ -4531,7 +4531,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGTUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTUconst [c] (MOVWconst [d]))
// cond: uint32(c) > uint32(d)
@@ -4623,7 +4623,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUzero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGTUzero(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTUzero (MOVWconst [d]))
// cond: d != 0
@@ -4657,7 +4657,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTconst [c] (MOVWconst [d]))
// cond: c > d
@@ -4821,7 +4821,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTzero(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSGTzero(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTzero (MOVWconst [d]))
// cond: d > 0
@@ -4855,7 +4855,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSLL(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVWconst [c]))
@@ -4873,7 +4873,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSLLconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSLLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVWconst [d]))
// result: (MOVWconst [d<<uint32(c)])
@@ -4889,7 +4889,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRA(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVWconst [c]))
@@ -4907,7 +4907,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRAconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSRAconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVWconst [d]))
// result: (MOVWconst [d>>uint32(c)])
@@ -4923,7 +4923,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRL(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVWconst [c]))
@@ -4941,7 +4941,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRLconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSRLconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int32(uint32(d)>>uint32(c))])
@@ -4957,7 +4957,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSUB(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB x (MOVWconst [c]))
@@ -5009,7 +5009,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSUBconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSSUBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -5063,7 +5063,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSXOR(v *ssa.Value) bool {
+func rewriteValue_OpMIPSXOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVWconst [c]))
@@ -5095,7 +5095,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSXORconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPSXORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -5135,7 +5135,7 @@
}
return false
}
-func rewriteValueMIPS_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5156,7 +5156,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5177,7 +5177,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5194,7 +5194,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5211,7 +5211,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5232,7 +5232,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5253,7 +5253,7 @@
return true
}
}
-func rewriteValueMIPS_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5620,7 +5620,7 @@
}
return false
}
-func rewriteValueMIPS_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5643,7 +5643,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5662,7 +5662,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5678,7 +5678,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5694,7 +5694,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5717,7 +5717,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5736,7 +5736,7 @@
return true
}
}
-func rewriteValueMIPS_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -5748,7 +5748,7 @@
return true
}
}
-func rewriteValueMIPS_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVWaddr [int32(off)] ptr)
@@ -5774,7 +5774,7 @@
return true
}
}
-func rewriteValueMIPS_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5802,7 +5802,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5830,7 +5830,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5858,7 +5858,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5886,7 +5886,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5913,7 +5913,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5938,7 +5938,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5980,7 +5980,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6007,7 +6007,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6033,7 +6033,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6057,7 +6057,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6104,7 +6104,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6130,7 +6130,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6155,7 +6155,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6178,7 +6178,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -6215,7 +6215,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6240,7 +6240,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6264,7 +6264,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6286,7 +6286,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -6325,7 +6325,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6349,7 +6349,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6376,7 +6376,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6401,7 +6401,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6443,7 +6443,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6470,7 +6470,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6496,7 +6496,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6520,7 +6520,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6567,7 +6567,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6593,7 +6593,7 @@
return true
}
}
-func rewriteValueMIPS_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6805,7 +6805,7 @@
}
return false
}
-func rewriteValueMIPS_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7024,7 +7024,7 @@
}
return false
}
-func rewriteValueMIPS_OpSignmask(v *ssa.Value) bool {
+func rewriteValue_OpSignmask(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SRAconst x [31])
@@ -7036,7 +7036,7 @@
return true
}
}
-func rewriteValueMIPS_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -7052,7 +7052,7 @@
return true
}
}
-func rewriteValueMIPS_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7133,7 +7133,7 @@
}
return false
}
-func rewriteValueMIPS_OpSub32withcarry(v *ssa.Value) bool {
+func rewriteValue_OpSub32withcarry(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7152,7 +7152,7 @@
return true
}
}
-func rewriteValueMIPS_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7431,7 +7431,7 @@
}
return false
}
-func rewriteValueMIPS_OpZeromask(v *ssa.Value) bool {
+func rewriteValue_OpZeromask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7448,7 +7448,7 @@
return true
}
}
-func rewriteBlockMIPS(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.BlockMIPSEQ:
// match: (EQ (FPFlagTrue cmp) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/rewriteMIPS64.go b/src/cmd/compile/internal/ssarewrite/rewritemips64/rewriteMIPS64.go
similarity index 91%
rename from src/cmd/compile/internal/ssacompile/rewriteMIPS64.go
rename to src/cmd/compile/internal/ssarewrite/rewritemips64/rewriteMIPS64.go
index 64301a1..19f2740 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritemips64/rewriteMIPS64.go
@@ -1,13 +1,13 @@
// Code generated from _gen/MIPS64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritemips64
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueMIPS64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpMIPS64ABSD
@@ -34,7 +34,7 @@
v.Op = ssaop.OpMIPS64ADDV
return true
case ssaop.OpAddr:
- return rewriteValueMIPS64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpMIPS64AND
return true
@@ -60,9 +60,9 @@
v.Op = ssaop.OpMIPS64LoweredAtomicAnd32
return true
case ssaop.OpAtomicAnd8:
- return rewriteValueMIPS64_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValueMIPS64_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap64:
v.Op = ssaop.OpMIPS64LoweredAtomicCas64
return true
@@ -88,7 +88,7 @@
v.Op = ssaop.OpMIPS64LoweredAtomicOr32
return true
case ssaop.OpAtomicOr8:
- return rewriteValueMIPS64_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
v.Op = ssaop.OpMIPS64LoweredAtomicStore32
return true
@@ -102,34 +102,34 @@
v.Op = ssaop.OpMIPS64LoweredAtomicStore64
return true
case ssaop.OpAvg64u:
- return rewriteValueMIPS64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpClosureCall:
v.Op = ssaop.OpMIPS64CALLclosure
return true
case ssaop.OpCom16:
- return rewriteValueMIPS64_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValueMIPS64_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom64:
- return rewriteValueMIPS64_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpCom8:
- return rewriteValueMIPS64_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpConst16:
- return rewriteValueMIPS64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueMIPS64_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
- return rewriteValueMIPS64_OpConst32F(v)
+ return rewriteValue_OpConst32F(v)
case ssaop.OpConst64:
- return rewriteValueMIPS64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
- return rewriteValueMIPS64_OpConst64F(v)
+ return rewriteValue_OpConst64F(v)
case ssaop.OpConst8:
- return rewriteValueMIPS64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueMIPS64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueMIPS64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCvt32Fto32:
v.Op = ssaop.OpMIPS64TRUNCFW
return true
@@ -164,43 +164,43 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueMIPS64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueMIPS64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueMIPS64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpMIPS64DIVF
return true
case ssaop.OpDiv32u:
- return rewriteValueMIPS64_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValueMIPS64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpMIPS64DIVD
return true
case ssaop.OpDiv64u:
- return rewriteValueMIPS64_OpDiv64u(v)
+ return rewriteValue_OpDiv64u(v)
case ssaop.OpDiv8:
- return rewriteValueMIPS64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueMIPS64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueMIPS64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueMIPS64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueMIPS64_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValueMIPS64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValueMIPS64_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueMIPS64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueMIPS64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueMIPS64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpGetCallerPC:
v.Op = ssaop.OpMIPS64LoweredGetCallerPC
return true
@@ -211,229 +211,229 @@
v.Op = ssaop.OpMIPS64LoweredGetClosurePtr
return true
case ssaop.OpHmul32:
- return rewriteValueMIPS64_OpHmul32(v)
+ return rewriteValue_OpHmul32(v)
case ssaop.OpHmul32u:
- return rewriteValueMIPS64_OpHmul32u(v)
+ return rewriteValue_OpHmul32u(v)
case ssaop.OpHmul64:
- return rewriteValueMIPS64_OpHmul64(v)
+ return rewriteValue_OpHmul64(v)
case ssaop.OpHmul64u:
- return rewriteValueMIPS64_OpHmul64u(v)
+ return rewriteValue_OpHmul64u(v)
case ssaop.OpInterCall:
v.Op = ssaop.OpMIPS64CALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValueMIPS64_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueMIPS64_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueMIPS64_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValueMIPS64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueMIPS64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueMIPS64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueMIPS64_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueMIPS64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueMIPS64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValueMIPS64_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValueMIPS64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueMIPS64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueMIPS64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueMIPS64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueMIPS64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueMIPS64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueMIPS64_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueMIPS64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValueMIPS64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValueMIPS64_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValueMIPS64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValueMIPS64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueMIPS64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueMIPS64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueMIPS64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueMIPS64_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueMIPS64_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueMIPS64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueMIPS64_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueMIPS64_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueMIPS64_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueMIPS64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueMIPS64_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueMIPS64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueMIPS64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueMIPS64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueMIPS64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueMIPS64_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueMIPS64_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueMIPS64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueMIPS64_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMIPS64ADDV:
- return rewriteValueMIPS64_OpMIPS64ADDV(v)
+ return rewriteValue_OpMIPS64ADDV(v)
case ssaop.OpMIPS64ADDVconst:
- return rewriteValueMIPS64_OpMIPS64ADDVconst(v)
+ return rewriteValue_OpMIPS64ADDVconst(v)
case ssaop.OpMIPS64AND:
- return rewriteValueMIPS64_OpMIPS64AND(v)
+ return rewriteValue_OpMIPS64AND(v)
case ssaop.OpMIPS64ANDconst:
- return rewriteValueMIPS64_OpMIPS64ANDconst(v)
+ return rewriteValue_OpMIPS64ANDconst(v)
case ssaop.OpMIPS64LoweredAtomicAdd32:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32(v)
+ return rewriteValue_OpMIPS64LoweredAtomicAdd32(v)
case ssaop.OpMIPS64LoweredAtomicAdd64:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64(v)
+ return rewriteValue_OpMIPS64LoweredAtomicAdd64(v)
case ssaop.OpMIPS64LoweredAtomicStore32:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32(v)
+ return rewriteValue_OpMIPS64LoweredAtomicStore32(v)
case ssaop.OpMIPS64LoweredAtomicStore64:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64(v)
+ return rewriteValue_OpMIPS64LoweredAtomicStore64(v)
case ssaop.OpMIPS64LoweredPanicBoundsCR:
- return rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpMIPS64LoweredPanicBoundsCR(v)
case ssaop.OpMIPS64LoweredPanicBoundsRC:
- return rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpMIPS64LoweredPanicBoundsRC(v)
case ssaop.OpMIPS64LoweredPanicBoundsRR:
- return rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpMIPS64LoweredPanicBoundsRR(v)
case ssaop.OpMIPS64MOVBUload:
- return rewriteValueMIPS64_OpMIPS64MOVBUload(v)
+ return rewriteValue_OpMIPS64MOVBUload(v)
case ssaop.OpMIPS64MOVBUreg:
- return rewriteValueMIPS64_OpMIPS64MOVBUreg(v)
+ return rewriteValue_OpMIPS64MOVBUreg(v)
case ssaop.OpMIPS64MOVBload:
- return rewriteValueMIPS64_OpMIPS64MOVBload(v)
+ return rewriteValue_OpMIPS64MOVBload(v)
case ssaop.OpMIPS64MOVBreg:
- return rewriteValueMIPS64_OpMIPS64MOVBreg(v)
+ return rewriteValue_OpMIPS64MOVBreg(v)
case ssaop.OpMIPS64MOVBstore:
- return rewriteValueMIPS64_OpMIPS64MOVBstore(v)
+ return rewriteValue_OpMIPS64MOVBstore(v)
case ssaop.OpMIPS64MOVDF:
- return rewriteValueMIPS64_OpMIPS64MOVDF(v)
+ return rewriteValue_OpMIPS64MOVDF(v)
case ssaop.OpMIPS64MOVDload:
- return rewriteValueMIPS64_OpMIPS64MOVDload(v)
+ return rewriteValue_OpMIPS64MOVDload(v)
case ssaop.OpMIPS64MOVDstore:
- return rewriteValueMIPS64_OpMIPS64MOVDstore(v)
+ return rewriteValue_OpMIPS64MOVDstore(v)
case ssaop.OpMIPS64MOVFload:
- return rewriteValueMIPS64_OpMIPS64MOVFload(v)
+ return rewriteValue_OpMIPS64MOVFload(v)
case ssaop.OpMIPS64MOVFstore:
- return rewriteValueMIPS64_OpMIPS64MOVFstore(v)
+ return rewriteValue_OpMIPS64MOVFstore(v)
case ssaop.OpMIPS64MOVHUload:
- return rewriteValueMIPS64_OpMIPS64MOVHUload(v)
+ return rewriteValue_OpMIPS64MOVHUload(v)
case ssaop.OpMIPS64MOVHUreg:
- return rewriteValueMIPS64_OpMIPS64MOVHUreg(v)
+ return rewriteValue_OpMIPS64MOVHUreg(v)
case ssaop.OpMIPS64MOVHload:
- return rewriteValueMIPS64_OpMIPS64MOVHload(v)
+ return rewriteValue_OpMIPS64MOVHload(v)
case ssaop.OpMIPS64MOVHreg:
- return rewriteValueMIPS64_OpMIPS64MOVHreg(v)
+ return rewriteValue_OpMIPS64MOVHreg(v)
case ssaop.OpMIPS64MOVHstore:
- return rewriteValueMIPS64_OpMIPS64MOVHstore(v)
+ return rewriteValue_OpMIPS64MOVHstore(v)
case ssaop.OpMIPS64MOVVload:
- return rewriteValueMIPS64_OpMIPS64MOVVload(v)
+ return rewriteValue_OpMIPS64MOVVload(v)
case ssaop.OpMIPS64MOVVnop:
- return rewriteValueMIPS64_OpMIPS64MOVVnop(v)
+ return rewriteValue_OpMIPS64MOVVnop(v)
case ssaop.OpMIPS64MOVVreg:
- return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
+ return rewriteValue_OpMIPS64MOVVreg(v)
case ssaop.OpMIPS64MOVVstore:
- return rewriteValueMIPS64_OpMIPS64MOVVstore(v)
+ return rewriteValue_OpMIPS64MOVVstore(v)
case ssaop.OpMIPS64MOVWUload:
- return rewriteValueMIPS64_OpMIPS64MOVWUload(v)
+ return rewriteValue_OpMIPS64MOVWUload(v)
case ssaop.OpMIPS64MOVWUreg:
- return rewriteValueMIPS64_OpMIPS64MOVWUreg(v)
+ return rewriteValue_OpMIPS64MOVWUreg(v)
case ssaop.OpMIPS64MOVWload:
- return rewriteValueMIPS64_OpMIPS64MOVWload(v)
+ return rewriteValue_OpMIPS64MOVWload(v)
case ssaop.OpMIPS64MOVWreg:
- return rewriteValueMIPS64_OpMIPS64MOVWreg(v)
+ return rewriteValue_OpMIPS64MOVWreg(v)
case ssaop.OpMIPS64MOVWstore:
- return rewriteValueMIPS64_OpMIPS64MOVWstore(v)
+ return rewriteValue_OpMIPS64MOVWstore(v)
case ssaop.OpMIPS64NEGV:
- return rewriteValueMIPS64_OpMIPS64NEGV(v)
+ return rewriteValue_OpMIPS64NEGV(v)
case ssaop.OpMIPS64OR:
- return rewriteValueMIPS64_OpMIPS64OR(v)
+ return rewriteValue_OpMIPS64OR(v)
case ssaop.OpMIPS64ORconst:
- return rewriteValueMIPS64_OpMIPS64ORconst(v)
+ return rewriteValue_OpMIPS64ORconst(v)
case ssaop.OpMIPS64SGT:
- return rewriteValueMIPS64_OpMIPS64SGT(v)
+ return rewriteValue_OpMIPS64SGT(v)
case ssaop.OpMIPS64SGTU:
- return rewriteValueMIPS64_OpMIPS64SGTU(v)
+ return rewriteValue_OpMIPS64SGTU(v)
case ssaop.OpMIPS64SGTUconst:
- return rewriteValueMIPS64_OpMIPS64SGTUconst(v)
+ return rewriteValue_OpMIPS64SGTUconst(v)
case ssaop.OpMIPS64SGTconst:
- return rewriteValueMIPS64_OpMIPS64SGTconst(v)
+ return rewriteValue_OpMIPS64SGTconst(v)
case ssaop.OpMIPS64SLLV:
- return rewriteValueMIPS64_OpMIPS64SLLV(v)
+ return rewriteValue_OpMIPS64SLLV(v)
case ssaop.OpMIPS64SLLVconst:
- return rewriteValueMIPS64_OpMIPS64SLLVconst(v)
+ return rewriteValue_OpMIPS64SLLVconst(v)
case ssaop.OpMIPS64SRAV:
- return rewriteValueMIPS64_OpMIPS64SRAV(v)
+ return rewriteValue_OpMIPS64SRAV(v)
case ssaop.OpMIPS64SRAVconst:
- return rewriteValueMIPS64_OpMIPS64SRAVconst(v)
+ return rewriteValue_OpMIPS64SRAVconst(v)
case ssaop.OpMIPS64SRLV:
- return rewriteValueMIPS64_OpMIPS64SRLV(v)
+ return rewriteValue_OpMIPS64SRLV(v)
case ssaop.OpMIPS64SRLVconst:
- return rewriteValueMIPS64_OpMIPS64SRLVconst(v)
+ return rewriteValue_OpMIPS64SRLVconst(v)
case ssaop.OpMIPS64SUBV:
- return rewriteValueMIPS64_OpMIPS64SUBV(v)
+ return rewriteValue_OpMIPS64SUBV(v)
case ssaop.OpMIPS64SUBVconst:
- return rewriteValueMIPS64_OpMIPS64SUBVconst(v)
+ return rewriteValue_OpMIPS64SUBVconst(v)
case ssaop.OpMIPS64XOR:
- return rewriteValueMIPS64_OpMIPS64XOR(v)
+ return rewriteValue_OpMIPS64XOR(v)
case ssaop.OpMIPS64XORconst:
- return rewriteValueMIPS64_OpMIPS64XORconst(v)
+ return rewriteValue_OpMIPS64XORconst(v)
case ssaop.OpMod16:
- return rewriteValueMIPS64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueMIPS64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueMIPS64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueMIPS64_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValueMIPS64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
- return rewriteValueMIPS64_OpMod64u(v)
+ return rewriteValue_OpMod64u(v)
case ssaop.OpMod8:
- return rewriteValueMIPS64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueMIPS64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueMIPS64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
- return rewriteValueMIPS64_OpMul16(v)
+ return rewriteValue_OpMul16(v)
case ssaop.OpMul32:
- return rewriteValueMIPS64_OpMul32(v)
+ return rewriteValue_OpMul32(v)
case ssaop.OpMul32F:
v.Op = ssaop.OpMIPS64MULF
return true
case ssaop.OpMul64:
- return rewriteValueMIPS64_OpMul64(v)
+ return rewriteValue_OpMul64(v)
case ssaop.OpMul64F:
v.Op = ssaop.OpMIPS64MULD
return true
@@ -441,7 +441,7 @@
v.Op = ssaop.OpMIPS64MULVU
return true
case ssaop.OpMul8:
- return rewriteValueMIPS64_OpMul8(v)
+ return rewriteValue_OpMul8(v)
case ssaop.OpNeg16:
v.Op = ssaop.OpMIPS64NEGV
return true
@@ -461,29 +461,29 @@
v.Op = ssaop.OpMIPS64NEGV
return true
case ssaop.OpNeq16:
- return rewriteValueMIPS64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueMIPS64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueMIPS64_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValueMIPS64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValueMIPS64_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueMIPS64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpMIPS64XOR
return true
case ssaop.OpNeqPtr:
- return rewriteValueMIPS64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpMIPS64LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueMIPS64_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValueMIPS64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpMIPS64OR
return true
@@ -506,13 +506,13 @@
v.Op = ssaop.OpMIPS64LoweredPubBarrier
return true
case ssaop.OpRotateLeft16:
- return rewriteValueMIPS64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
- return rewriteValueMIPS64_OpRotateLeft32(v)
+ return rewriteValue_OpRotateLeft32(v)
case ssaop.OpRotateLeft64:
- return rewriteValueMIPS64_OpRotateLeft64(v)
+ return rewriteValue_OpRotateLeft64(v)
case ssaop.OpRotateLeft8:
- return rewriteValueMIPS64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpCopy
return true
@@ -520,73 +520,73 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueMIPS64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueMIPS64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueMIPS64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueMIPS64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueMIPS64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueMIPS64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueMIPS64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueMIPS64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueMIPS64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueMIPS64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueMIPS64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueMIPS64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueMIPS64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueMIPS64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueMIPS64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueMIPS64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueMIPS64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueMIPS64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueMIPS64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueMIPS64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueMIPS64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueMIPS64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueMIPS64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueMIPS64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueMIPS64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueMIPS64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueMIPS64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueMIPS64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueMIPS64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueMIPS64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueMIPS64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueMIPS64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueMIPS64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueMIPS64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpMIPS64MOVHreg
return true
@@ -606,7 +606,7 @@
v.Op = ssaop.OpMIPS64MOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValueMIPS64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpMIPS64SQRTD
return true
@@ -617,7 +617,7 @@
v.Op = ssaop.OpMIPS64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValueMIPS64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpMIPS64SUBV
return true
@@ -679,7 +679,7 @@
v.Op = ssaop.OpMIPS64XOR
return true
case ssaop.OpZero:
- return rewriteValueMIPS64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpMIPS64MOVHUreg
return true
@@ -701,7 +701,7 @@
}
return false
}
-func rewriteValueMIPS64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVVaddr {sym} base)
@@ -714,7 +714,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -802,7 +802,7 @@
}
return false
}
-func rewriteValueMIPS64_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -823,7 +823,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -891,7 +891,7 @@
}
return false
}
-func rewriteValueMIPS64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -911,7 +911,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -926,7 +926,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -941,7 +941,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -956,7 +956,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -971,7 +971,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -981,7 +981,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -991,7 +991,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32F(v *ssa.Value) bool {
+func rewriteValue_OpConst32F(v *ssa.Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [float64(val)])
for {
@@ -1001,7 +1001,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1011,7 +1011,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64F(v *ssa.Value) bool {
+func rewriteValue_OpConst64F(v *ssa.Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [float64(val)])
for {
@@ -1021,7 +1021,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVVconst [int64(val)])
for {
@@ -1031,7 +1031,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVVconst [int64(ssa.B2i(t))])
for {
@@ -1041,7 +1041,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVVconst [0])
for {
@@ -1050,7 +1050,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1071,7 +1071,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1092,7 +1092,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1113,7 +1113,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1134,7 +1134,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1151,7 +1151,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64u(v *ssa.Value) bool {
+func rewriteValue_OpDiv64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1168,7 +1168,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1189,7 +1189,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1210,7 +1210,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1233,7 +1233,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1256,7 +1256,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1272,7 +1272,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1291,7 +1291,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1307,7 +1307,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1330,7 +1330,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1349,7 +1349,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1368,7 +1368,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32(v *ssa.Value) bool {
+func rewriteValue_OpHmul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1392,7 +1392,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32u(v *ssa.Value) bool {
+func rewriteValue_OpHmul32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1416,7 +1416,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64(v *ssa.Value) bool {
+func rewriteValue_OpHmul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1433,7 +1433,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64u(v *ssa.Value) bool {
+func rewriteValue_OpHmul64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1450,7 +1450,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -1463,7 +1463,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1478,7 +1478,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1497,7 +1497,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1520,7 +1520,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1543,7 +1543,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1566,7 +1566,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1582,7 +1582,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1605,7 +1605,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1624,7 +1624,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1640,7 +1640,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1659,7 +1659,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1682,7 +1682,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1705,7 +1705,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1724,7 +1724,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1743,7 +1743,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1762,7 +1762,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1778,7 +1778,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1797,7 +1797,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 x y)
@@ -1810,7 +1810,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1826,7 +1826,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U x y)
@@ -1839,7 +1839,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1858,7 +1858,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1877,7 +1877,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2022,7 +2022,7 @@
}
return false
}
-func rewriteValueMIPS64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2062,7 +2062,7 @@
}
return false
}
-func rewriteValueMIPS64_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2088,7 +2088,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2114,7 +2114,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2138,7 +2138,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2164,7 +2164,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2190,7 +2190,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2216,7 +2216,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2240,7 +2240,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2266,7 +2266,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2292,7 +2292,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2318,7 +2318,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2342,7 +2342,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2368,7 +2368,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2394,7 +2394,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2420,7 +2420,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2444,7 +2444,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2470,7 +2470,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMIPS64ADDV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64ADDV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDV x (MOVVconst <t> [c]))
@@ -2511,7 +2511,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ADDVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64ADDVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
// cond: ssa.Is32Bit(off1+int64(off2))
@@ -2593,7 +2593,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64AND(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVVconst [c]))
@@ -2628,7 +2628,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVVconst [0])
@@ -2678,7 +2678,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredAtomicAdd32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2702,7 +2702,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredAtomicAdd64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2726,7 +2726,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredAtomicStore32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2744,7 +2744,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredAtomicStore64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2762,7 +2762,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVVconst [c]) mem)
@@ -2783,7 +2783,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVVconst [c]) mem)
@@ -2804,7 +2804,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2842,7 +2842,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2922,7 +2922,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -2959,7 +2959,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3039,7 +3039,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -3076,7 +3076,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3231,7 +3231,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDF(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVDF(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDF (ABSD (MOVFD x)))
// result: (ABSF x)
@@ -3265,7 +3265,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3332,7 +3332,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3402,7 +3402,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVFload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3469,7 +3469,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVFstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3539,7 +3539,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3619,7 +3619,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -3678,7 +3678,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3758,7 +3758,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -3839,7 +3839,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3960,7 +3960,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVVload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4057,7 +4057,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVnop(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVVnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVVnop (MOVVconst [c]))
// result: (MOVVconst [c])
@@ -4072,7 +4072,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVVreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVVreg x)
// cond: x.Uses == 1
@@ -4099,7 +4099,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVVstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4169,7 +4169,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVWUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4269,7 +4269,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -4350,7 +4350,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4430,7 +4430,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -4544,7 +4544,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4648,7 +4648,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NEGV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64NEGV(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGV (SUBV x y))
// result: (SUBV y x)
@@ -4685,7 +4685,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64OR(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (MOVVconst [c]))
@@ -4720,7 +4720,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ORconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64ORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -4774,7 +4774,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGT(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SGT(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGT (MOVVconst [c]) x)
@@ -4807,7 +4807,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTU(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SGTU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGTU (MOVVconst [c]) x)
@@ -4840,7 +4840,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTUconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SGTUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTUconst [c] (MOVVconst [d]))
// cond: uint64(c)>uint64(d)
@@ -4932,7 +4932,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SGTconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SGTconst [c] (MOVVconst [d]))
// cond: c>d
@@ -5108,7 +5108,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SLLV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLLV _ (MOVVconst [c]))
@@ -5141,7 +5141,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SLLVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLVconst [c] (MOVVconst [d]))
// result: (MOVVconst [d<<uint64(c)])
@@ -5157,7 +5157,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SRAV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAV x (MOVVconst [c]))
@@ -5192,7 +5192,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SRAVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRAVconst [c] (MOVVconst [d]))
// result: (MOVVconst [d>>uint64(c)])
@@ -5208,7 +5208,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SRLV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRLV _ (MOVVconst [c]))
@@ -5241,7 +5241,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SRLVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLVconst [c] (MOVVconst [d]))
// result: (MOVVconst [int64(uint64(d)>>uint64(c))])
@@ -5257,7 +5257,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBV(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SUBV(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBV x (MOVVconst [c]))
@@ -5313,7 +5313,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64SUBVconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBVconst [0] x)
// result: x
@@ -5375,7 +5375,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XOR(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVVconst [c]))
@@ -5411,7 +5411,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XORconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -5455,7 +5455,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5476,7 +5476,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5497,7 +5497,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5518,7 +5518,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5539,7 +5539,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5556,7 +5556,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64u(v *ssa.Value) bool {
+func rewriteValue_OpMod64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5573,7 +5573,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5594,7 +5594,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5615,7 +5615,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6039,7 +6039,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMul16(v *ssa.Value) bool {
+func rewriteValue_OpMul16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6056,7 +6056,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul32(v *ssa.Value) bool {
+func rewriteValue_OpMul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6073,7 +6073,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64(v *ssa.Value) bool {
+func rewriteValue_OpMul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6090,7 +6090,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul8(v *ssa.Value) bool {
+func rewriteValue_OpMul8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6107,7 +6107,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6130,7 +6130,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6153,7 +6153,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6169,7 +6169,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6188,7 +6188,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6204,7 +6204,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6227,7 +6227,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6246,7 +6246,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -6258,7 +6258,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6307,7 +6307,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6335,7 +6335,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft32(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6363,7 +6363,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft64(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6391,7 +6391,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6419,7 +6419,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6447,7 +6447,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6475,7 +6475,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6501,7 +6501,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6529,7 +6529,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6557,7 +6557,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6585,7 +6585,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6611,7 +6611,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6639,7 +6639,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6667,7 +6667,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6695,7 +6695,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6721,7 +6721,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6749,7 +6749,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6777,7 +6777,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6805,7 +6805,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6831,7 +6831,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6859,7 +6859,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6885,7 +6885,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6911,7 +6911,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6935,7 +6935,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6961,7 +6961,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6987,7 +6987,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7013,7 +7013,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7037,7 +7037,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7063,7 +7063,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7091,7 +7091,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7119,7 +7119,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7145,7 +7145,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7173,7 +7173,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7201,7 +7201,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7229,7 +7229,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7255,7 +7255,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7283,7 +7283,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7423,7 +7423,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7687,7 +7687,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -7703,7 +7703,7 @@
return true
}
}
-func rewriteValueMIPS64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7799,7 +7799,7 @@
}
return false
}
-func rewriteValueMIPS64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8162,7 +8162,7 @@
}
return false
}
-func rewriteBlockMIPS64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
switch b.Kind {
case block.BlockMIPS64EQ:
// match: (EQ (FPFlagTrue cmp) yes no)
diff --git a/src/cmd/compile/internal/ssacompile/rewriteMIPS64latelower.go b/src/cmd/compile/internal/ssarewrite/rewritemips64latelower/rewriteMIPS64latelower.go
similarity index 61%
rename from src/cmd/compile/internal/ssacompile/rewriteMIPS64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewritemips64latelower/rewriteMIPS64latelower.go
index 645975e..000b014 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteMIPS64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritemips64latelower/rewriteMIPS64latelower.go
@@ -1,18 +1,18 @@
// Code generated from _gen/MIPS64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritemips64latelower
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueMIPS64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpMIPS64MOVVconst:
- return rewriteValueMIPS64latelower_OpMIPS64MOVVconst(v)
+ return rewriteValue_OpMIPS64MOVVconst(v)
}
return false
}
-func rewriteValueMIPS64latelower_OpMIPS64MOVVconst(v *ssa.Value) bool {
+func rewriteValue_OpMIPS64MOVVconst(v *ssa.Value) bool {
// match: (MOVVconst [0])
// result: (ZERO)
for {
@@ -24,6 +24,6 @@
}
return false
}
-func rewriteBlockMIPS64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/ppc64_helpers.go b/src/cmd/compile/internal/ssarewrite/rewriteppc64/ppc64_helpers.go
similarity index 99%
rename from src/cmd/compile/internal/ssacompile/ppc64_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewriteppc64/ppc64_helpers.go
index 218f7f4..a851bc8 100644
--- a/src/cmd/compile/internal/ssacompile/ppc64_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteppc64/ppc64_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewriteppc64
import (
"math/bits"
diff --git a/src/cmd/compile/internal/ssacompile/rewritePPC64.go b/src/cmd/compile/internal/ssarewrite/rewriteppc64/rewritePPC64.go
similarity index 92%
rename from src/cmd/compile/internal/ssacompile/rewritePPC64.go
rename to src/cmd/compile/internal/ssarewrite/rewriteppc64/rewritePPC64.go
index 6293649..b3c2ee0 100644
--- a/src/cmd/compile/internal/ssacompile/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteppc64/rewritePPC64.go
@@ -1,6 +1,6 @@
// Code generated from _gen/PPC64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteppc64
import "internal/buildcfg"
import "math"
@@ -9,7 +9,7 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuePPC64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpPPC64FABS
@@ -36,7 +36,7 @@
v.Op = ssaop.OpPPC64ADD
return true
case ssaop.OpAddr:
- return rewriteValuePPC64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpPPC64AND
return true
@@ -65,11 +65,11 @@
v.Op = ssaop.OpPPC64LoweredAtomicAnd8
return true
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValuePPC64_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap64:
- return rewriteValuePPC64_OpAtomicCompareAndSwap64(v)
+ return rewriteValue_OpAtomicCompareAndSwap64(v)
case ssaop.OpAtomicCompareAndSwapRel32:
- return rewriteValuePPC64_OpAtomicCompareAndSwapRel32(v)
+ return rewriteValue_OpAtomicCompareAndSwapRel32(v)
case ssaop.OpAtomicExchange32:
v.Op = ssaop.OpPPC64LoweredAtomicExchange32
return true
@@ -80,17 +80,17 @@
v.Op = ssaop.OpPPC64LoweredAtomicExchange8
return true
case ssaop.OpAtomicLoad32:
- return rewriteValuePPC64_OpAtomicLoad32(v)
+ return rewriteValue_OpAtomicLoad32(v)
case ssaop.OpAtomicLoad64:
- return rewriteValuePPC64_OpAtomicLoad64(v)
+ return rewriteValue_OpAtomicLoad64(v)
case ssaop.OpAtomicLoad8:
- return rewriteValuePPC64_OpAtomicLoad8(v)
+ return rewriteValue_OpAtomicLoad8(v)
case ssaop.OpAtomicLoadAcq32:
- return rewriteValuePPC64_OpAtomicLoadAcq32(v)
+ return rewriteValue_OpAtomicLoadAcq32(v)
case ssaop.OpAtomicLoadAcq64:
- return rewriteValuePPC64_OpAtomicLoadAcq64(v)
+ return rewriteValue_OpAtomicLoadAcq64(v)
case ssaop.OpAtomicLoadPtr:
- return rewriteValuePPC64_OpAtomicLoadPtr(v)
+ return rewriteValue_OpAtomicLoadPtr(v)
case ssaop.OpAtomicOr32:
v.Op = ssaop.OpPPC64LoweredAtomicOr32
return true
@@ -98,31 +98,31 @@
v.Op = ssaop.OpPPC64LoweredAtomicOr8
return true
case ssaop.OpAtomicStore32:
- return rewriteValuePPC64_OpAtomicStore32(v)
+ return rewriteValue_OpAtomicStore32(v)
case ssaop.OpAtomicStore64:
- return rewriteValuePPC64_OpAtomicStore64(v)
+ return rewriteValue_OpAtomicStore64(v)
case ssaop.OpAtomicStore8:
- return rewriteValuePPC64_OpAtomicStore8(v)
+ return rewriteValue_OpAtomicStore8(v)
case ssaop.OpAtomicStoreRel32:
- return rewriteValuePPC64_OpAtomicStoreRel32(v)
+ return rewriteValue_OpAtomicStoreRel32(v)
case ssaop.OpAtomicStoreRel64:
- return rewriteValuePPC64_OpAtomicStoreRel64(v)
+ return rewriteValue_OpAtomicStoreRel64(v)
case ssaop.OpAvg64u:
- return rewriteValuePPC64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValuePPC64_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValuePPC64_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValuePPC64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValuePPC64_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBswap16:
- return rewriteValuePPC64_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
- return rewriteValuePPC64_OpBswap32(v)
+ return rewriteValue_OpBswap32(v)
case ssaop.OpBswap64:
- return rewriteValuePPC64_OpBswap64(v)
+ return rewriteValue_OpBswap64(v)
case ssaop.OpCeil:
v.Op = ssaop.OpPPC64FCEIL
return true
@@ -130,86 +130,86 @@
v.Op = ssaop.OpPPC64CALLclosure
return true
case ssaop.OpCom16:
- return rewriteValuePPC64_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValuePPC64_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom64:
- return rewriteValuePPC64_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpCom8:
- return rewriteValuePPC64_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpCondSelect:
- return rewriteValuePPC64_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConst16:
- return rewriteValuePPC64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValuePPC64_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
v.Op = ssaop.OpPPC64FMOVSconst
return true
case ssaop.OpConst64:
- return rewriteValuePPC64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
v.Op = ssaop.OpPPC64FMOVDconst
return true
case ssaop.OpConst8:
- return rewriteValuePPC64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValuePPC64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValuePPC64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCopysign:
- return rewriteValuePPC64_OpCopysign(v)
+ return rewriteValue_OpCopysign(v)
case ssaop.OpCtz16:
- return rewriteValuePPC64_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz32:
- return rewriteValuePPC64_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz64:
- return rewriteValuePPC64_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz64NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz8:
- return rewriteValuePPC64_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCvt32Fto32:
- return rewriteValuePPC64_OpCvt32Fto32(v)
+ return rewriteValue_OpCvt32Fto32(v)
case ssaop.OpCvt32Fto64:
- return rewriteValuePPC64_OpCvt32Fto64(v)
+ return rewriteValue_OpCvt32Fto64(v)
case ssaop.OpCvt32Fto64F:
v.Op = ssaop.OpCopy
return true
case ssaop.OpCvt32to32F:
- return rewriteValuePPC64_OpCvt32to32F(v)
+ return rewriteValue_OpCvt32to32F(v)
case ssaop.OpCvt32to64F:
- return rewriteValuePPC64_OpCvt32to64F(v)
+ return rewriteValue_OpCvt32to64F(v)
case ssaop.OpCvt64Fto32:
- return rewriteValuePPC64_OpCvt64Fto32(v)
+ return rewriteValue_OpCvt64Fto32(v)
case ssaop.OpCvt64Fto32F:
v.Op = ssaop.OpPPC64FRSP
return true
case ssaop.OpCvt64Fto64:
- return rewriteValuePPC64_OpCvt64Fto64(v)
+ return rewriteValue_OpCvt64Fto64(v)
case ssaop.OpCvt64to32F:
- return rewriteValuePPC64_OpCvt64to32F(v)
+ return rewriteValue_OpCvt64to32F(v)
case ssaop.OpCvt64to64F:
- return rewriteValuePPC64_OpCvt64to64F(v)
+ return rewriteValue_OpCvt64to64F(v)
case ssaop.OpCvtBoolToUint8:
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValuePPC64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValuePPC64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValuePPC64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpPPC64FDIVS
return true
@@ -217,7 +217,7 @@
v.Op = ssaop.OpPPC64DIVWU
return true
case ssaop.OpDiv64:
- return rewriteValuePPC64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpPPC64FDIV
return true
@@ -225,25 +225,25 @@
v.Op = ssaop.OpPPC64DIVDU
return true
case ssaop.OpDiv8:
- return rewriteValuePPC64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValuePPC64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValuePPC64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValuePPC64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValuePPC64_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValuePPC64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValuePPC64_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValuePPC64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValuePPC64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValuePPC64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpFMA:
v.Op = ssaop.OpPPC64FMADD
return true
@@ -275,113 +275,113 @@
v.Op = ssaop.OpPPC64CALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValuePPC64_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValuePPC64_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValuePPC64_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValuePPC64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValuePPC64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValuePPC64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValuePPC64_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValuePPC64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValuePPC64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValuePPC64_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValuePPC64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValuePPC64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValuePPC64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValuePPC64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValuePPC64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValuePPC64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValuePPC64_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValuePPC64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValuePPC64_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValuePPC64_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValuePPC64_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValuePPC64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValuePPC64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValuePPC64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValuePPC64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValuePPC64_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValuePPC64_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValuePPC64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValuePPC64_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValuePPC64_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValuePPC64_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValuePPC64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValuePPC64_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValuePPC64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValuePPC64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValuePPC64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValuePPC64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValuePPC64_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValuePPC64_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValuePPC64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValuePPC64_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMax32F:
- return rewriteValuePPC64_OpMax32F(v)
+ return rewriteValue_OpMax32F(v)
case ssaop.OpMax64F:
- return rewriteValuePPC64_OpMax64F(v)
+ return rewriteValue_OpMax64F(v)
case ssaop.OpMin32F:
- return rewriteValuePPC64_OpMin32F(v)
+ return rewriteValue_OpMin32F(v)
case ssaop.OpMin64F:
- return rewriteValuePPC64_OpMin64F(v)
+ return rewriteValue_OpMin64F(v)
case ssaop.OpMod16:
- return rewriteValuePPC64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValuePPC64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValuePPC64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValuePPC64_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValuePPC64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
- return rewriteValuePPC64_OpMod64u(v)
+ return rewriteValue_OpMod64u(v)
case ssaop.OpMod8:
- return rewriteValuePPC64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValuePPC64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValuePPC64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpPPC64MULLW
return true
@@ -419,29 +419,29 @@
v.Op = ssaop.OpPPC64NEG
return true
case ssaop.OpNeq16:
- return rewriteValuePPC64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValuePPC64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValuePPC64_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValuePPC64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValuePPC64_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValuePPC64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpPPC64XOR
return true
case ssaop.OpNeqPtr:
- return rewriteValuePPC64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpPPC64LoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValuePPC64_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValuePPC64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpPPC64OR
return true
@@ -458,244 +458,244 @@
v.Op = ssaop.OpPPC64OR
return true
case ssaop.OpPPC64ADD:
- return rewriteValuePPC64_OpPPC64ADD(v)
+ return rewriteValue_OpPPC64ADD(v)
case ssaop.OpPPC64ADDC:
- return rewriteValuePPC64_OpPPC64ADDC(v)
+ return rewriteValue_OpPPC64ADDC(v)
case ssaop.OpPPC64ADDE:
- return rewriteValuePPC64_OpPPC64ADDE(v)
+ return rewriteValue_OpPPC64ADDE(v)
case ssaop.OpPPC64ADDconst:
- return rewriteValuePPC64_OpPPC64ADDconst(v)
+ return rewriteValue_OpPPC64ADDconst(v)
case ssaop.OpPPC64AND:
- return rewriteValuePPC64_OpPPC64AND(v)
+ return rewriteValue_OpPPC64AND(v)
case ssaop.OpPPC64ANDN:
- return rewriteValuePPC64_OpPPC64ANDN(v)
+ return rewriteValue_OpPPC64ANDN(v)
case ssaop.OpPPC64ANDconst:
- return rewriteValuePPC64_OpPPC64ANDconst(v)
+ return rewriteValue_OpPPC64ANDconst(v)
case ssaop.OpPPC64BRD:
- return rewriteValuePPC64_OpPPC64BRD(v)
+ return rewriteValue_OpPPC64BRD(v)
case ssaop.OpPPC64BRH:
- return rewriteValuePPC64_OpPPC64BRH(v)
+ return rewriteValue_OpPPC64BRH(v)
case ssaop.OpPPC64BRW:
- return rewriteValuePPC64_OpPPC64BRW(v)
+ return rewriteValue_OpPPC64BRW(v)
case ssaop.OpPPC64CLRLSLDI:
- return rewriteValuePPC64_OpPPC64CLRLSLDI(v)
+ return rewriteValue_OpPPC64CLRLSLDI(v)
case ssaop.OpPPC64CMP:
- return rewriteValuePPC64_OpPPC64CMP(v)
+ return rewriteValue_OpPPC64CMP(v)
case ssaop.OpPPC64CMPU:
- return rewriteValuePPC64_OpPPC64CMPU(v)
+ return rewriteValue_OpPPC64CMPU(v)
case ssaop.OpPPC64CMPUconst:
- return rewriteValuePPC64_OpPPC64CMPUconst(v)
+ return rewriteValue_OpPPC64CMPUconst(v)
case ssaop.OpPPC64CMPW:
- return rewriteValuePPC64_OpPPC64CMPW(v)
+ return rewriteValue_OpPPC64CMPW(v)
case ssaop.OpPPC64CMPWU:
- return rewriteValuePPC64_OpPPC64CMPWU(v)
+ return rewriteValue_OpPPC64CMPWU(v)
case ssaop.OpPPC64CMPWUconst:
- return rewriteValuePPC64_OpPPC64CMPWUconst(v)
+ return rewriteValue_OpPPC64CMPWUconst(v)
case ssaop.OpPPC64CMPWconst:
- return rewriteValuePPC64_OpPPC64CMPWconst(v)
+ return rewriteValue_OpPPC64CMPWconst(v)
case ssaop.OpPPC64CMPconst:
- return rewriteValuePPC64_OpPPC64CMPconst(v)
+ return rewriteValue_OpPPC64CMPconst(v)
case ssaop.OpPPC64Equal:
- return rewriteValuePPC64_OpPPC64Equal(v)
+ return rewriteValue_OpPPC64Equal(v)
case ssaop.OpPPC64FABS:
- return rewriteValuePPC64_OpPPC64FABS(v)
+ return rewriteValue_OpPPC64FABS(v)
case ssaop.OpPPC64FADD:
- return rewriteValuePPC64_OpPPC64FADD(v)
+ return rewriteValue_OpPPC64FADD(v)
case ssaop.OpPPC64FADDS:
- return rewriteValuePPC64_OpPPC64FADDS(v)
+ return rewriteValue_OpPPC64FADDS(v)
case ssaop.OpPPC64FCEIL:
- return rewriteValuePPC64_OpPPC64FCEIL(v)
+ return rewriteValue_OpPPC64FCEIL(v)
case ssaop.OpPPC64FFLOOR:
- return rewriteValuePPC64_OpPPC64FFLOOR(v)
+ return rewriteValue_OpPPC64FFLOOR(v)
case ssaop.OpPPC64FGreaterEqual:
- return rewriteValuePPC64_OpPPC64FGreaterEqual(v)
+ return rewriteValue_OpPPC64FGreaterEqual(v)
case ssaop.OpPPC64FGreaterThan:
- return rewriteValuePPC64_OpPPC64FGreaterThan(v)
+ return rewriteValue_OpPPC64FGreaterThan(v)
case ssaop.OpPPC64FLessEqual:
- return rewriteValuePPC64_OpPPC64FLessEqual(v)
+ return rewriteValue_OpPPC64FLessEqual(v)
case ssaop.OpPPC64FLessThan:
- return rewriteValuePPC64_OpPPC64FLessThan(v)
+ return rewriteValue_OpPPC64FLessThan(v)
case ssaop.OpPPC64FMOVDload:
- return rewriteValuePPC64_OpPPC64FMOVDload(v)
+ return rewriteValue_OpPPC64FMOVDload(v)
case ssaop.OpPPC64FMOVDstore:
- return rewriteValuePPC64_OpPPC64FMOVDstore(v)
+ return rewriteValue_OpPPC64FMOVDstore(v)
case ssaop.OpPPC64FMOVSload:
- return rewriteValuePPC64_OpPPC64FMOVSload(v)
+ return rewriteValue_OpPPC64FMOVSload(v)
case ssaop.OpPPC64FMOVSstore:
- return rewriteValuePPC64_OpPPC64FMOVSstore(v)
+ return rewriteValue_OpPPC64FMOVSstore(v)
case ssaop.OpPPC64FNEG:
- return rewriteValuePPC64_OpPPC64FNEG(v)
+ return rewriteValue_OpPPC64FNEG(v)
case ssaop.OpPPC64FSQRT:
- return rewriteValuePPC64_OpPPC64FSQRT(v)
+ return rewriteValue_OpPPC64FSQRT(v)
case ssaop.OpPPC64FSUB:
- return rewriteValuePPC64_OpPPC64FSUB(v)
+ return rewriteValue_OpPPC64FSUB(v)
case ssaop.OpPPC64FSUBS:
- return rewriteValuePPC64_OpPPC64FSUBS(v)
+ return rewriteValue_OpPPC64FSUBS(v)
case ssaop.OpPPC64FTRUNC:
- return rewriteValuePPC64_OpPPC64FTRUNC(v)
+ return rewriteValue_OpPPC64FTRUNC(v)
case ssaop.OpPPC64GreaterEqual:
- return rewriteValuePPC64_OpPPC64GreaterEqual(v)
+ return rewriteValue_OpPPC64GreaterEqual(v)
case ssaop.OpPPC64GreaterThan:
- return rewriteValuePPC64_OpPPC64GreaterThan(v)
+ return rewriteValue_OpPPC64GreaterThan(v)
case ssaop.OpPPC64ISEL:
- return rewriteValuePPC64_OpPPC64ISEL(v)
+ return rewriteValue_OpPPC64ISEL(v)
case ssaop.OpPPC64LessEqual:
- return rewriteValuePPC64_OpPPC64LessEqual(v)
+ return rewriteValue_OpPPC64LessEqual(v)
case ssaop.OpPPC64LessThan:
- return rewriteValuePPC64_OpPPC64LessThan(v)
+ return rewriteValue_OpPPC64LessThan(v)
case ssaop.OpPPC64LoweredPanicBoundsCR:
- return rewriteValuePPC64_OpPPC64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpPPC64LoweredPanicBoundsCR(v)
case ssaop.OpPPC64LoweredPanicBoundsRC:
- return rewriteValuePPC64_OpPPC64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpPPC64LoweredPanicBoundsRC(v)
case ssaop.OpPPC64LoweredPanicBoundsRR:
- return rewriteValuePPC64_OpPPC64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpPPC64LoweredPanicBoundsRR(v)
case ssaop.OpPPC64MFVSRD:
- return rewriteValuePPC64_OpPPC64MFVSRD(v)
+ return rewriteValue_OpPPC64MFVSRD(v)
case ssaop.OpPPC64MOVBZload:
- return rewriteValuePPC64_OpPPC64MOVBZload(v)
+ return rewriteValue_OpPPC64MOVBZload(v)
case ssaop.OpPPC64MOVBZloadidx:
- return rewriteValuePPC64_OpPPC64MOVBZloadidx(v)
+ return rewriteValue_OpPPC64MOVBZloadidx(v)
case ssaop.OpPPC64MOVBZreg:
- return rewriteValuePPC64_OpPPC64MOVBZreg(v)
+ return rewriteValue_OpPPC64MOVBZreg(v)
case ssaop.OpPPC64MOVBreg:
- return rewriteValuePPC64_OpPPC64MOVBreg(v)
+ return rewriteValue_OpPPC64MOVBreg(v)
case ssaop.OpPPC64MOVBstore:
- return rewriteValuePPC64_OpPPC64MOVBstore(v)
+ return rewriteValue_OpPPC64MOVBstore(v)
case ssaop.OpPPC64MOVBstoreidx:
- return rewriteValuePPC64_OpPPC64MOVBstoreidx(v)
+ return rewriteValue_OpPPC64MOVBstoreidx(v)
case ssaop.OpPPC64MOVBstorezero:
- return rewriteValuePPC64_OpPPC64MOVBstorezero(v)
+ return rewriteValue_OpPPC64MOVBstorezero(v)
case ssaop.OpPPC64MOVDaddr:
- return rewriteValuePPC64_OpPPC64MOVDaddr(v)
+ return rewriteValue_OpPPC64MOVDaddr(v)
case ssaop.OpPPC64MOVDload:
- return rewriteValuePPC64_OpPPC64MOVDload(v)
+ return rewriteValue_OpPPC64MOVDload(v)
case ssaop.OpPPC64MOVDloadidx:
- return rewriteValuePPC64_OpPPC64MOVDloadidx(v)
+ return rewriteValue_OpPPC64MOVDloadidx(v)
case ssaop.OpPPC64MOVDstore:
- return rewriteValuePPC64_OpPPC64MOVDstore(v)
+ return rewriteValue_OpPPC64MOVDstore(v)
case ssaop.OpPPC64MOVDstoreidx:
- return rewriteValuePPC64_OpPPC64MOVDstoreidx(v)
+ return rewriteValue_OpPPC64MOVDstoreidx(v)
case ssaop.OpPPC64MOVDstorezero:
- return rewriteValuePPC64_OpPPC64MOVDstorezero(v)
+ return rewriteValue_OpPPC64MOVDstorezero(v)
case ssaop.OpPPC64MOVHBRstore:
- return rewriteValuePPC64_OpPPC64MOVHBRstore(v)
+ return rewriteValue_OpPPC64MOVHBRstore(v)
case ssaop.OpPPC64MOVHZload:
- return rewriteValuePPC64_OpPPC64MOVHZload(v)
+ return rewriteValue_OpPPC64MOVHZload(v)
case ssaop.OpPPC64MOVHZloadidx:
- return rewriteValuePPC64_OpPPC64MOVHZloadidx(v)
+ return rewriteValue_OpPPC64MOVHZloadidx(v)
case ssaop.OpPPC64MOVHZreg:
- return rewriteValuePPC64_OpPPC64MOVHZreg(v)
+ return rewriteValue_OpPPC64MOVHZreg(v)
case ssaop.OpPPC64MOVHload:
- return rewriteValuePPC64_OpPPC64MOVHload(v)
+ return rewriteValue_OpPPC64MOVHload(v)
case ssaop.OpPPC64MOVHloadidx:
- return rewriteValuePPC64_OpPPC64MOVHloadidx(v)
+ return rewriteValue_OpPPC64MOVHloadidx(v)
case ssaop.OpPPC64MOVHreg:
- return rewriteValuePPC64_OpPPC64MOVHreg(v)
+ return rewriteValue_OpPPC64MOVHreg(v)
case ssaop.OpPPC64MOVHstore:
- return rewriteValuePPC64_OpPPC64MOVHstore(v)
+ return rewriteValue_OpPPC64MOVHstore(v)
case ssaop.OpPPC64MOVHstoreidx:
- return rewriteValuePPC64_OpPPC64MOVHstoreidx(v)
+ return rewriteValue_OpPPC64MOVHstoreidx(v)
case ssaop.OpPPC64MOVHstorezero:
- return rewriteValuePPC64_OpPPC64MOVHstorezero(v)
+ return rewriteValue_OpPPC64MOVHstorezero(v)
case ssaop.OpPPC64MOVWBRstore:
- return rewriteValuePPC64_OpPPC64MOVWBRstore(v)
+ return rewriteValue_OpPPC64MOVWBRstore(v)
case ssaop.OpPPC64MOVWZload:
- return rewriteValuePPC64_OpPPC64MOVWZload(v)
+ return rewriteValue_OpPPC64MOVWZload(v)
case ssaop.OpPPC64MOVWZloadidx:
- return rewriteValuePPC64_OpPPC64MOVWZloadidx(v)
+ return rewriteValue_OpPPC64MOVWZloadidx(v)
case ssaop.OpPPC64MOVWZreg:
- return rewriteValuePPC64_OpPPC64MOVWZreg(v)
+ return rewriteValue_OpPPC64MOVWZreg(v)
case ssaop.OpPPC64MOVWload:
- return rewriteValuePPC64_OpPPC64MOVWload(v)
+ return rewriteValue_OpPPC64MOVWload(v)
case ssaop.OpPPC64MOVWloadidx:
- return rewriteValuePPC64_OpPPC64MOVWloadidx(v)
+ return rewriteValue_OpPPC64MOVWloadidx(v)
case ssaop.OpPPC64MOVWreg:
- return rewriteValuePPC64_OpPPC64MOVWreg(v)
+ return rewriteValue_OpPPC64MOVWreg(v)
case ssaop.OpPPC64MOVWstore:
- return rewriteValuePPC64_OpPPC64MOVWstore(v)
+ return rewriteValue_OpPPC64MOVWstore(v)
case ssaop.OpPPC64MOVWstoreidx:
- return rewriteValuePPC64_OpPPC64MOVWstoreidx(v)
+ return rewriteValue_OpPPC64MOVWstoreidx(v)
case ssaop.OpPPC64MOVWstorezero:
- return rewriteValuePPC64_OpPPC64MOVWstorezero(v)
+ return rewriteValue_OpPPC64MOVWstorezero(v)
case ssaop.OpPPC64MTVSRD:
- return rewriteValuePPC64_OpPPC64MTVSRD(v)
+ return rewriteValue_OpPPC64MTVSRD(v)
case ssaop.OpPPC64MULLD:
- return rewriteValuePPC64_OpPPC64MULLD(v)
+ return rewriteValue_OpPPC64MULLD(v)
case ssaop.OpPPC64MULLW:
- return rewriteValuePPC64_OpPPC64MULLW(v)
+ return rewriteValue_OpPPC64MULLW(v)
case ssaop.OpPPC64NEG:
- return rewriteValuePPC64_OpPPC64NEG(v)
+ return rewriteValue_OpPPC64NEG(v)
case ssaop.OpPPC64NOR:
- return rewriteValuePPC64_OpPPC64NOR(v)
+ return rewriteValue_OpPPC64NOR(v)
case ssaop.OpPPC64NotEqual:
- return rewriteValuePPC64_OpPPC64NotEqual(v)
+ return rewriteValue_OpPPC64NotEqual(v)
case ssaop.OpPPC64OR:
- return rewriteValuePPC64_OpPPC64OR(v)
+ return rewriteValue_OpPPC64OR(v)
case ssaop.OpPPC64ORN:
- return rewriteValuePPC64_OpPPC64ORN(v)
+ return rewriteValue_OpPPC64ORN(v)
case ssaop.OpPPC64ORconst:
- return rewriteValuePPC64_OpPPC64ORconst(v)
+ return rewriteValue_OpPPC64ORconst(v)
case ssaop.OpPPC64RLWINM:
- return rewriteValuePPC64_OpPPC64RLWINM(v)
+ return rewriteValue_OpPPC64RLWINM(v)
case ssaop.OpPPC64ROTL:
- return rewriteValuePPC64_OpPPC64ROTL(v)
+ return rewriteValue_OpPPC64ROTL(v)
case ssaop.OpPPC64ROTLW:
- return rewriteValuePPC64_OpPPC64ROTLW(v)
+ return rewriteValue_OpPPC64ROTLW(v)
case ssaop.OpPPC64ROTLWconst:
- return rewriteValuePPC64_OpPPC64ROTLWconst(v)
+ return rewriteValue_OpPPC64ROTLWconst(v)
case ssaop.OpPPC64SETBC:
- return rewriteValuePPC64_OpPPC64SETBC(v)
+ return rewriteValue_OpPPC64SETBC(v)
case ssaop.OpPPC64SETBCR:
- return rewriteValuePPC64_OpPPC64SETBCR(v)
+ return rewriteValue_OpPPC64SETBCR(v)
case ssaop.OpPPC64SLD:
- return rewriteValuePPC64_OpPPC64SLD(v)
+ return rewriteValue_OpPPC64SLD(v)
case ssaop.OpPPC64SLDconst:
- return rewriteValuePPC64_OpPPC64SLDconst(v)
+ return rewriteValue_OpPPC64SLDconst(v)
case ssaop.OpPPC64SLW:
- return rewriteValuePPC64_OpPPC64SLW(v)
+ return rewriteValue_OpPPC64SLW(v)
case ssaop.OpPPC64SLWconst:
- return rewriteValuePPC64_OpPPC64SLWconst(v)
+ return rewriteValue_OpPPC64SLWconst(v)
case ssaop.OpPPC64SRAD:
- return rewriteValuePPC64_OpPPC64SRAD(v)
+ return rewriteValue_OpPPC64SRAD(v)
case ssaop.OpPPC64SRAW:
- return rewriteValuePPC64_OpPPC64SRAW(v)
+ return rewriteValue_OpPPC64SRAW(v)
case ssaop.OpPPC64SRD:
- return rewriteValuePPC64_OpPPC64SRD(v)
+ return rewriteValue_OpPPC64SRD(v)
case ssaop.OpPPC64SRW:
- return rewriteValuePPC64_OpPPC64SRW(v)
+ return rewriteValue_OpPPC64SRW(v)
case ssaop.OpPPC64SRWconst:
- return rewriteValuePPC64_OpPPC64SRWconst(v)
+ return rewriteValue_OpPPC64SRWconst(v)
case ssaop.OpPPC64SUB:
- return rewriteValuePPC64_OpPPC64SUB(v)
+ return rewriteValue_OpPPC64SUB(v)
case ssaop.OpPPC64SUBE:
- return rewriteValuePPC64_OpPPC64SUBE(v)
+ return rewriteValue_OpPPC64SUBE(v)
case ssaop.OpPPC64SUBFCconst:
- return rewriteValuePPC64_OpPPC64SUBFCconst(v)
+ return rewriteValue_OpPPC64SUBFCconst(v)
case ssaop.OpPPC64XOR:
- return rewriteValuePPC64_OpPPC64XOR(v)
+ return rewriteValue_OpPPC64XOR(v)
case ssaop.OpPPC64XORconst:
- return rewriteValuePPC64_OpPPC64XORconst(v)
+ return rewriteValue_OpPPC64XORconst(v)
case ssaop.OpPanicBounds:
v.Op = ssaop.OpPPC64LoweredPanicBoundsRR
return true
case ssaop.OpPopCount16:
- return rewriteValuePPC64_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValuePPC64_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
v.Op = ssaop.OpPPC64POPCNTD
return true
case ssaop.OpPopCount8:
- return rewriteValuePPC64_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpPrefetchCache:
- return rewriteValuePPC64_OpPrefetchCache(v)
+ return rewriteValue_OpPrefetchCache(v)
case ssaop.OpPrefetchCacheStreamed:
- return rewriteValuePPC64_OpPrefetchCacheStreamed(v)
+ return rewriteValue_OpPrefetchCacheStreamed(v)
case ssaop.OpPubBarrier:
v.Op = ssaop.OpPPC64LoweredPubBarrier
return true
case ssaop.OpRotateLeft16:
- return rewriteValuePPC64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
v.Op = ssaop.OpPPC64ROTLW
return true
@@ -703,7 +703,7 @@
v.Op = ssaop.OpPPC64ROTL
return true
case ssaop.OpRotateLeft8:
- return rewriteValuePPC64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound:
v.Op = ssaop.OpPPC64FROUND
return true
@@ -714,75 +714,75 @@
v.Op = ssaop.OpPPC64LoweredRound64F
return true
case ssaop.OpRsh16Ux16:
- return rewriteValuePPC64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValuePPC64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValuePPC64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValuePPC64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValuePPC64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValuePPC64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValuePPC64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValuePPC64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValuePPC64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValuePPC64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValuePPC64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValuePPC64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValuePPC64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValuePPC64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValuePPC64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValuePPC64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValuePPC64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValuePPC64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValuePPC64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValuePPC64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValuePPC64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValuePPC64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValuePPC64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValuePPC64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValuePPC64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValuePPC64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValuePPC64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValuePPC64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValuePPC64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValuePPC64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValuePPC64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValuePPC64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValuePPC64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValuePPC64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSelectN:
- return rewriteValuePPC64_OpSelectN(v)
+ return rewriteValue_OpSelectN(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpPPC64MOVHreg
return true
@@ -802,7 +802,7 @@
v.Op = ssaop.OpPPC64MOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValuePPC64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpPPC64FSQRT
return true
@@ -813,7 +813,7 @@
v.Op = ssaop.OpPPC64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValuePPC64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpPPC64SUB
return true
@@ -845,17 +845,17 @@
v.Op = ssaop.OpPPC64FTRUNC
return true
case ssaop.OpTrunc16to8:
- return rewriteValuePPC64_OpTrunc16to8(v)
+ return rewriteValue_OpTrunc16to8(v)
case ssaop.OpTrunc32to16:
- return rewriteValuePPC64_OpTrunc32to16(v)
+ return rewriteValue_OpTrunc32to16(v)
case ssaop.OpTrunc32to8:
- return rewriteValuePPC64_OpTrunc32to8(v)
+ return rewriteValue_OpTrunc32to8(v)
case ssaop.OpTrunc64to16:
- return rewriteValuePPC64_OpTrunc64to16(v)
+ return rewriteValue_OpTrunc64to16(v)
case ssaop.OpTrunc64to32:
- return rewriteValuePPC64_OpTrunc64to32(v)
+ return rewriteValue_OpTrunc64to32(v)
case ssaop.OpTrunc64to8:
- return rewriteValuePPC64_OpTrunc64to8(v)
+ return rewriteValue_OpTrunc64to8(v)
case ssaop.OpWB:
v.Op = ssaop.OpPPC64LoweredWB
return true
@@ -872,7 +872,7 @@
v.Op = ssaop.OpPPC64XOR
return true
case ssaop.OpZero:
- return rewriteValuePPC64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpPPC64MOVHZreg
return true
@@ -894,7 +894,7 @@
}
return false
}
-func rewriteValuePPC64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} [0] base)
@@ -908,7 +908,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -926,7 +926,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -944,7 +944,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwapRel32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwapRel32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -962,7 +962,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -976,7 +976,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -990,7 +990,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -1004,7 +1004,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadAcq32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadAcq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadAcq32 ptr mem)
@@ -1018,7 +1018,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadAcq64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadAcq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadAcq64 ptr mem)
@@ -1032,7 +1032,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadPtr(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -1046,7 +1046,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1062,7 +1062,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1078,7 +1078,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1094,7 +1094,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStoreRel32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStoreRel32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1110,7 +1110,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStoreRel64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStoreRel64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1126,7 +1126,7 @@
return true
}
}
-func rewriteValuePPC64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1146,7 +1146,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1161,7 +1161,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1177,7 +1177,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1193,7 +1193,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1208,7 +1208,7 @@
return true
}
}
-func rewriteValuePPC64_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1263,7 +1263,7 @@
}
return false
}
-func rewriteValuePPC64_OpBswap32(v *ssa.Value) bool {
+func rewriteValue_OpBswap32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1318,7 +1318,7 @@
}
return false
}
-func rewriteValuePPC64_OpBswap64(v *ssa.Value) bool {
+func rewriteValue_OpBswap64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1373,7 +1373,7 @@
}
return false
}
-func rewriteValuePPC64_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (NOR x x)
@@ -1384,7 +1384,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (NOR x x)
@@ -1395,7 +1395,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com64 x)
// result: (NOR x x)
@@ -1406,7 +1406,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (NOR x x)
@@ -1417,7 +1417,7 @@
return true
}
}
-func rewriteValuePPC64_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1476,7 +1476,7 @@
}
return false
}
-func rewriteValuePPC64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1486,7 +1486,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1496,7 +1496,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1506,7 +1506,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1516,7 +1516,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVDconst [ssa.B2i(t)])
for {
@@ -1526,7 +1526,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -1535,7 +1535,7 @@
return true
}
}
-func rewriteValuePPC64_OpCopysign(v *ssa.Value) bool {
+func rewriteValue_OpCopysign(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Copysign x y)
@@ -1548,7 +1548,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1589,7 +1589,7 @@
}
return false
}
-func rewriteValuePPC64_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1628,7 +1628,7 @@
}
return false
}
-func rewriteValuePPC64_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1663,7 +1663,7 @@
}
return false
}
-func rewriteValuePPC64_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1704,7 +1704,7 @@
}
return false
}
-func rewriteValuePPC64_OpCvt32Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1719,7 +1719,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1734,7 +1734,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1751,7 +1751,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1768,7 +1768,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1783,7 +1783,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto64(v *ssa.Value) bool {
+func rewriteValue_OpCvt64Fto64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1798,7 +1798,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt64to32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1813,7 +1813,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt64to64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1828,7 +1828,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1851,7 +1851,7 @@
}
return false
}
-func rewriteValuePPC64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1870,7 +1870,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 [false] x y)
@@ -1887,7 +1887,7 @@
}
return false
}
-func rewriteValuePPC64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 [false] x y)
@@ -1904,7 +1904,7 @@
}
return false
}
-func rewriteValuePPC64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1923,7 +1923,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1942,7 +1942,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1985,7 +1985,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2001,7 +2001,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2017,7 +2017,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2033,7 +2033,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2049,7 +2049,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2092,7 +2092,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2110,7 +2110,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2126,7 +2126,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2142,7 +2142,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -2157,7 +2157,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2173,7 +2173,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2194,7 +2194,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2215,7 +2215,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2231,7 +2231,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2247,7 +2247,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2263,7 +2263,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2279,7 +2279,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2295,7 +2295,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2311,7 +2311,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2332,7 +2332,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2353,7 +2353,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2374,7 +2374,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2395,7 +2395,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2411,7 +2411,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2427,7 +2427,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2443,7 +2443,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2459,7 +2459,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2475,7 +2475,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2491,7 +2491,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2512,7 +2512,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2533,7 +2533,7 @@
return true
}
}
-func rewriteValuePPC64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2682,7 +2682,7 @@
}
return false
}
-func rewriteValuePPC64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2722,7 +2722,7 @@
}
return false
}
-func rewriteValuePPC64_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2764,7 +2764,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2803,7 +2803,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2859,7 +2859,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2901,7 +2901,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2941,7 +2941,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2978,7 +2978,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3032,7 +3032,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3072,7 +3072,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3112,7 +3112,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3149,7 +3149,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3203,7 +3203,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3243,7 +3243,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3285,7 +3285,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3324,7 +3324,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3380,7 +3380,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3422,7 +3422,7 @@
return true
}
}
-func rewriteValuePPC64_OpMax32F(v *ssa.Value) bool {
+func rewriteValue_OpMax32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Max32F x y)
@@ -3440,7 +3440,7 @@
}
return false
}
-func rewriteValuePPC64_OpMax64F(v *ssa.Value) bool {
+func rewriteValue_OpMax64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Max64F x y)
@@ -3458,7 +3458,7 @@
}
return false
}
-func rewriteValuePPC64_OpMin32F(v *ssa.Value) bool {
+func rewriteValue_OpMin32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Min32F x y)
@@ -3476,7 +3476,7 @@
}
return false
}
-func rewriteValuePPC64_OpMin64F(v *ssa.Value) bool {
+func rewriteValue_OpMin64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Min64F x y)
@@ -3494,7 +3494,7 @@
}
return false
}
-func rewriteValuePPC64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3513,7 +3513,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3532,7 +3532,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3569,7 +3569,7 @@
}
return false
}
-func rewriteValuePPC64_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3606,7 +3606,7 @@
}
return false
}
-func rewriteValuePPC64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3643,7 +3643,7 @@
}
return false
}
-func rewriteValuePPC64_OpMod64u(v *ssa.Value) bool {
+func rewriteValue_OpMod64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3680,7 +3680,7 @@
}
return false
}
-func rewriteValuePPC64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3699,7 +3699,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3718,7 +3718,7 @@
return true
}
}
-func rewriteValuePPC64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3934,7 +3934,7 @@
}
return false
}
-func rewriteValuePPC64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3977,7 +3977,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3993,7 +3993,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4009,7 +4009,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4025,7 +4025,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4041,7 +4041,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4084,7 +4084,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4100,7 +4100,7 @@
return true
}
}
-func rewriteValuePPC64_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -4112,7 +4112,7 @@
return true
}
}
-func rewriteValuePPC64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4128,7 +4128,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64ADD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4200,7 +4200,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ADDC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDC x (MOVDconst [y]))
@@ -4225,7 +4225,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDE(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ADDE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4268,7 +4268,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ADDconst <at> [z] l:(MULLD x y))
@@ -4398,7 +4398,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64AND(v *ssa.Value) bool {
+func rewriteValue_OpPPC64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND <t> x (MOVDconst [m]))
@@ -4711,7 +4711,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ANDN(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ANDN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDN (MOVDconst [c]) (MOVDconst [d]))
@@ -4731,7 +4731,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [m] (ROTLWconst [r] x))
// cond: ssa.IsPPC64WordRotateMask(m)
@@ -4998,7 +4998,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64BRD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64BRD(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5049,7 +5049,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64BRH(v *ssa.Value) bool {
+func rewriteValue_OpPPC64BRH(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5100,7 +5100,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64BRW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64BRW(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5151,7 +5151,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CLRLSLDI(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CLRLSLDI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CLRLSLDI [c] (SRWconst [s] x))
// cond: ssa.MergePPC64ClrlsldiSrw(int64(c),s) != 0
@@ -5210,7 +5210,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMP(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5267,7 +5267,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPU(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5324,7 +5324,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPUconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPUconst [d] (ANDconst z [c]))
// cond: uint64(d) > uint64(c)
@@ -5403,7 +5403,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5484,7 +5484,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWU(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPWU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5565,7 +5565,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWUconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPWUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPWUconst [d] (ANDconst z [c]))
// cond: uint64(d) > uint64(c)
@@ -5644,7 +5644,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -5708,7 +5708,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
@@ -5757,7 +5757,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64Equal(v *ssa.Value) bool {
+func rewriteValue_OpPPC64Equal(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Equal (FlagEQ))
// result: (MOVDconst [1])
@@ -5810,7 +5810,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FABS(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FABS(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FABS (FMOVDconst [x]))
// result: (FMOVDconst [math.Abs(x)])
@@ -5825,7 +5825,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADD (FMUL x y) z)
@@ -5855,7 +5855,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADDS(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FADDS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS (FMULS x y) z)
@@ -5885,7 +5885,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FCEIL(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FCEIL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FCEIL (FMOVDconst [x]))
// result: (FMOVDconst [math.Ceil(x)])
@@ -5900,7 +5900,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FFLOOR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FFLOOR(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FFLOOR (FMOVDconst [x]))
// result: (FMOVDconst [math.Floor(x)])
@@ -5915,7 +5915,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FGreaterEqual(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FGreaterEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5934,7 +5934,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FGreaterThan(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FGreaterThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FGreaterThan cmp)
// result: (SETBC [1] cmp)
@@ -5946,7 +5946,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FLessEqual(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FLessEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5965,7 +5965,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FLessThan(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FLessThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FLessThan cmp)
// result: (SETBC [0] cmp)
@@ -5977,7 +5977,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVDload [off] {sym} ptr (MOVDstore [off] {sym} ptr x _))
@@ -6043,7 +6043,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6112,7 +6112,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FMOVSload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVSload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -6161,7 +6161,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FMOVSstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6213,7 +6213,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FNEG(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FNEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FNEG (FABS x))
// result: (FNABS x)
@@ -6239,7 +6239,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSQRT(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FSQRT(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FSQRT (FMOVDconst [x]))
// cond: x >= 0
@@ -6258,7 +6258,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUB(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FSUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUB (FMUL x y) z)
@@ -6286,7 +6286,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUBS(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FSUBS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS (FMULS x y) z)
@@ -6314,7 +6314,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FTRUNC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64FTRUNC(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FTRUNC (FMOVDconst [x]))
// result: (FMOVDconst [math.Trunc(x)])
@@ -6329,7 +6329,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterEqual(v *ssa.Value) bool {
+func rewriteValue_OpPPC64GreaterEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqual (FlagEQ))
// result: (MOVDconst [1])
@@ -6382,7 +6382,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64GreaterThan(v *ssa.Value) bool {
+func rewriteValue_OpPPC64GreaterThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (GreaterThan (FlagEQ))
// result: (MOVDconst [0])
@@ -6435,7 +6435,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64ISEL(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ISEL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6846,7 +6846,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LessEqual(v *ssa.Value) bool {
+func rewriteValue_OpPPC64LessEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessEqual (FlagEQ))
// result: (MOVDconst [1])
@@ -6899,7 +6899,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64LessThan(v *ssa.Value) bool {
+func rewriteValue_OpPPC64LessThan(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LessThan (FlagEQ))
// result: (MOVDconst [0])
@@ -6952,7 +6952,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVDconst [c]) mem)
@@ -6973,7 +6973,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVDconst [c]) mem)
@@ -6994,7 +6994,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7032,7 +7032,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MFVSRD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MFVSRD(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7072,7 +7072,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -7143,7 +7143,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBZloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7185,7 +7185,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7640,7 +7640,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7846,7 +7846,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8157,7 +8157,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -8392,7 +8392,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstorezero(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVBstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -8441,7 +8441,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDaddr(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDaddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDaddr {sym} [n] p:(ADD x y))
// cond: sym == nil && n == 0
@@ -8474,7 +8474,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off] {sym} ptr (FMOVDstore [off] {sym} ptr x _))
@@ -8562,7 +8562,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8604,7 +8604,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8756,7 +8756,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -8834,7 +8834,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstorezero(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVDstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -8883,7 +8883,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHBRstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHBRstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8941,7 +8941,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -9012,7 +9012,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHZloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9054,7 +9054,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9480,7 +9480,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -9551,7 +9551,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9593,7 +9593,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9849,7 +9849,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10052,7 +10052,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10186,7 +10186,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstorezero(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVHstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -10235,7 +10235,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWBRstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWBRstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10267,7 +10267,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -10338,7 +10338,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWZloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10380,7 +10380,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10837,7 +10837,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -10908,7 +10908,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWloadidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWloadidx(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10950,7 +10950,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11227,7 +11227,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11396,7 +11396,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11502,7 +11502,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstorezero(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MOVWstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -11551,7 +11551,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MTVSRD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MTVSRD(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11595,7 +11595,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MULLD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MULLD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLD x (MOVDconst [c]))
@@ -11620,7 +11620,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MULLW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64MULLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLW x (MOVDconst [c]))
@@ -11645,7 +11645,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64NEG(v *ssa.Value) bool {
+func rewriteValue_OpPPC64NEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEG (ADDconst [c] x))
// cond: ssa.Is32Bit(-c)
@@ -11705,7 +11705,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64NOR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64NOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NOR (MOVDconst [c]) (MOVDconst [d]))
@@ -11728,7 +11728,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64NotEqual(v *ssa.Value) bool {
+func rewriteValue_OpPPC64NotEqual(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NotEqual (FlagEQ))
// result: (MOVDconst [0])
@@ -11781,7 +11781,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64OR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR <t> x (MOVDconst [m]))
@@ -11884,7 +11884,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORN(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ORN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x (MOVDconst [-1]))
@@ -11914,7 +11914,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [c] (ORconst [d] x))
// result: (ORconst [c|d] x)
@@ -11952,7 +11952,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64RLWINM(v *ssa.Value) bool {
+func rewriteValue_OpPPC64RLWINM(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RLWINM [r] (MOVHZreg u))
// cond: mergePPC64RlwinmAnd(r,0xFFFF) != 0
@@ -11991,7 +11991,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ROTL(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ROTL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTL x (MOVDconst [c]))
@@ -12009,7 +12009,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ROTLW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ROTLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTLW x (MOVDconst [c]))
@@ -12027,7 +12027,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ROTLWconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ROTLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ROTLWconst [r] (AND (MOVDconst [m]) x))
// cond: ssa.IsPPC64WordRotateMask(m)
@@ -12076,7 +12076,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SETBC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SETBC(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -12311,7 +12311,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SETBCR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SETBCR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -12544,7 +12544,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SLD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SLD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLD x (MOVDconst [c]))
@@ -12562,7 +12562,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SLDconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SLDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLDconst [l] (SRWconst [r] x))
// cond: ssa.MergePPC64SldiSrw(l,r) != 0
@@ -12738,7 +12738,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SLW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLW x (MOVDconst [c]))
@@ -12756,7 +12756,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SLWconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLWconst [s] (MOVWZreg w))
// result: (SLWconst [s] w)
@@ -12891,7 +12891,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SRAD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SRAD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAD x (MOVDconst [c]))
@@ -12909,7 +12909,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SRAW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SRAW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAW x (MOVDconst [c]))
@@ -12927,7 +12927,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SRD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SRD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRD x (MOVDconst [c]))
@@ -12945,7 +12945,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SRW(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SRW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRW x (MOVDconst [c]))
@@ -12963,7 +12963,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SRWconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SRWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRWconst (ANDconst [m] x) [s])
// cond: ssa.MergePPC64RShiftMask(m>>uint(s),s,32) == 0
@@ -13053,7 +13053,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SUB(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB x (MOVDconst [c]))
@@ -13092,7 +13092,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SUBE(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SUBE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13120,7 +13120,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SUBFCconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SUBFCconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBFCconst [c] (NEG x))
// result: (ADDconst [c] x)
@@ -13166,7 +13166,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XOR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR <t> x (MOVDconst [m]))
@@ -13251,7 +13251,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XORconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [c] (XORconst [d] x))
// result: (XORconst [c^d] x)
@@ -13305,7 +13305,7 @@
}
return false
}
-func rewriteValuePPC64_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13320,7 +13320,7 @@
return true
}
}
-func rewriteValuePPC64_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13335,7 +13335,7 @@
return true
}
}
-func rewriteValuePPC64_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13350,7 +13350,7 @@
return true
}
}
-func rewriteValuePPC64_OpPrefetchCache(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCache(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCache ptr mem)
@@ -13364,7 +13364,7 @@
return true
}
}
-func rewriteValuePPC64_OpPrefetchCacheStreamed(v *ssa.Value) bool {
+func rewriteValue_OpPrefetchCacheStreamed(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (PrefetchCacheStreamed ptr mem)
@@ -13378,7 +13378,7 @@
return true
}
}
-func rewriteValuePPC64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13406,7 +13406,7 @@
}
return false
}
-func rewriteValuePPC64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13434,7 +13434,7 @@
}
return false
}
-func rewriteValuePPC64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13478,7 +13478,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13519,7 +13519,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13579,7 +13579,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13623,7 +13623,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13668,7 +13668,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13710,7 +13710,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13790,7 +13790,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13835,7 +13835,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13875,7 +13875,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13912,7 +13912,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13966,7 +13966,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14006,7 +14006,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14047,7 +14047,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14084,7 +14084,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14155,7 +14155,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14196,7 +14196,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14236,7 +14236,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14273,7 +14273,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14327,7 +14327,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14367,7 +14367,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14408,7 +14408,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14445,7 +14445,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14516,7 +14516,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14557,7 +14557,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14601,7 +14601,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14642,7 +14642,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14702,7 +14702,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14746,7 +14746,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14791,7 +14791,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14833,7 +14833,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14913,7 +14913,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14958,7 +14958,7 @@
return true
}
}
-func rewriteValuePPC64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -15030,7 +15030,7 @@
}
return false
}
-func rewriteValuePPC64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -15152,7 +15152,7 @@
}
return false
}
-func rewriteValuePPC64_OpSelectN(v *ssa.Value) bool {
+func rewriteValue_OpSelectN(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -15228,7 +15228,7 @@
}
return false
}
-func rewriteValuePPC64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -15244,7 +15244,7 @@
return true
}
}
-func rewriteValuePPC64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15340,7 +15340,7 @@
}
return false
}
-func rewriteValuePPC64_OpTrunc16to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc16to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 <t> x)
// cond: t.IsSigned()
@@ -15364,7 +15364,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to16(v *ssa.Value) bool {
+func rewriteValue_OpTrunc32to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 <t> x)
// cond: t.IsSigned()
@@ -15388,7 +15388,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc32to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 <t> x)
// cond: t.IsSigned()
@@ -15412,7 +15412,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to16(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 <t> x)
// cond: t.IsSigned()
@@ -15436,7 +15436,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to32(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 <t> x)
// cond: t.IsSigned()
@@ -15460,7 +15460,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to8(v *ssa.Value) bool {
+func rewriteValue_OpTrunc64to8(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 <t> x)
// cond: t.IsSigned()
@@ -15484,7 +15484,7 @@
return true
}
}
-func rewriteValuePPC64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15744,7 +15744,7 @@
}
return false
}
-func rewriteBlockPPC64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockPPC64EQ:
diff --git a/src/cmd/compile/internal/ssacompile/ppc64latelower_helpers.go b/src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/ppc64latelower_helpers.go
similarity index 98%
rename from src/cmd/compile/internal/ssacompile/ppc64latelower_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/ppc64latelower_helpers.go
index 82bebb3..196b388 100644
--- a/src/cmd/compile/internal/ssacompile/ppc64latelower_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/ppc64latelower_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewriteppc64latelower
import (
"cmd/compile/internal/ssa"
diff --git a/src/cmd/compile/internal/ssacompile/rewritePPC64latelower.go b/src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/rewritePPC64latelower.go
similarity index 93%
rename from src/cmd/compile/internal/ssacompile/rewritePPC64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/rewritePPC64latelower.go
index 7137b06..cd33010 100644
--- a/src/cmd/compile/internal/ssacompile/rewritePPC64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteppc64latelower/rewritePPC64latelower.go
@@ -1,35 +1,35 @@
// Code generated from _gen/PPC64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteppc64latelower
import "internal/buildcfg"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValuePPC64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpPPC64ADD:
- return rewriteValuePPC64latelower_OpPPC64ADD(v)
+ return rewriteValue_OpPPC64ADD(v)
case ssaop.OpPPC64AND:
- return rewriteValuePPC64latelower_OpPPC64AND(v)
+ return rewriteValue_OpPPC64AND(v)
case ssaop.OpPPC64ANDconst:
- return rewriteValuePPC64latelower_OpPPC64ANDconst(v)
+ return rewriteValue_OpPPC64ANDconst(v)
case ssaop.OpPPC64CMPconst:
- return rewriteValuePPC64latelower_OpPPC64CMPconst(v)
+ return rewriteValue_OpPPC64CMPconst(v)
case ssaop.OpPPC64ISEL:
- return rewriteValuePPC64latelower_OpPPC64ISEL(v)
+ return rewriteValue_OpPPC64ISEL(v)
case ssaop.OpPPC64RLDICL:
- return rewriteValuePPC64latelower_OpPPC64RLDICL(v)
+ return rewriteValue_OpPPC64RLDICL(v)
case ssaop.OpPPC64RLDICLCC:
- return rewriteValuePPC64latelower_OpPPC64RLDICLCC(v)
+ return rewriteValue_OpPPC64RLDICLCC(v)
case ssaop.OpPPC64SETBC:
- return rewriteValuePPC64latelower_OpPPC64SETBC(v)
+ return rewriteValue_OpPPC64SETBC(v)
case ssaop.OpPPC64SETBCR:
- return rewriteValuePPC64latelower_OpPPC64SETBCR(v)
+ return rewriteValue_OpPPC64SETBCR(v)
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64ADD(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD (MOVDconst [m]) x)
@@ -54,7 +54,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64AND(v *ssa.Value) bool {
+func rewriteValue_OpPPC64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x:(MOVDconst [m]) n)
@@ -123,7 +123,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64ANDconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [m] x)
// cond: ssa.IsPPC64ValidShiftMask(m)
@@ -141,7 +141,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64CMPconst(v *ssa.Value) bool {
+func rewriteValue_OpPPC64CMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPconst [0] z:(ADD x y))
// cond: v.Block == z.Block
@@ -602,7 +602,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64ISEL(v *ssa.Value) bool {
+func rewriteValue_OpPPC64ISEL(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -636,7 +636,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64RLDICL(v *ssa.Value) bool {
+func rewriteValue_OpPPC64RLDICL(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RLDICL [em] x:(SRDconst [s] a))
// cond: (em&0xFF0000) == 0
@@ -659,7 +659,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64RLDICLCC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64RLDICLCC(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RLDICLCC [a] x)
// cond: convertPPC64RldiclAndccconst(a) != 0
@@ -677,7 +677,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64SETBC(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SETBC(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -737,7 +737,7 @@
}
return false
}
-func rewriteValuePPC64latelower_OpPPC64SETBCR(v *ssa.Value) bool {
+func rewriteValue_OpPPC64SETBCR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -797,6 +797,6 @@
}
return false
}
-func rewriteBlockPPC64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/rewriteRISCV64.go b/src/cmd/compile/internal/ssarewrite/rewriteriscv64/rewriteRISCV64.go
similarity index 92%
rename from src/cmd/compile/internal/ssacompile/rewriteRISCV64.go
rename to src/cmd/compile/internal/ssarewrite/rewriteriscv64/rewriteRISCV64.go
index 8299f9c..c79265a 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteriscv64/rewriteRISCV64.go
@@ -1,6 +1,6 @@
// Code generated from _gen/RISCV64.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteriscv64
import "internal/buildcfg"
import "math"
@@ -10,7 +10,7 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueRISCV64(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpRISCV64FABSD
@@ -37,7 +37,7 @@
v.Op = ssaop.OpRISCV64ADD
return true
case ssaop.OpAddr:
- return rewriteValueRISCV64_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpRISCV64AND
return true
@@ -63,9 +63,9 @@
v.Op = ssaop.OpRISCV64LoweredAtomicAnd32
return true
case ssaop.OpAtomicAnd8:
- return rewriteValueRISCV64_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValueRISCV64_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap64:
v.Op = ssaop.OpRISCV64LoweredAtomicCas64
return true
@@ -91,7 +91,7 @@
v.Op = ssaop.OpRISCV64LoweredAtomicOr32
return true
case ssaop.OpAtomicOr8:
- return rewriteValueRISCV64_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
v.Op = ssaop.OpRISCV64LoweredAtomicStore32
return true
@@ -105,19 +105,19 @@
v.Op = ssaop.OpRISCV64LoweredAtomicStore64
return true
case ssaop.OpAvg64u:
- return rewriteValueRISCV64_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValueRISCV64_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueRISCV64_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueRISCV64_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueRISCV64_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBswap16:
- return rewriteValueRISCV64_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
- return rewriteValueRISCV64_OpBswap32(v)
+ return rewriteValue_OpBswap32(v)
case ssaop.OpBswap64:
v.Op = ssaop.OpRISCV64REV8
return true
@@ -137,30 +137,30 @@
v.Op = ssaop.OpRISCV64NOT
return true
case ssaop.OpCondSelect:
- return rewriteValueRISCV64_OpCondSelect(v)
+ return rewriteValue_OpCondSelect(v)
case ssaop.OpConst16:
- return rewriteValueRISCV64_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueRISCV64_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
v.Op = ssaop.OpRISCV64FMOVFconst
return true
case ssaop.OpConst64:
- return rewriteValueRISCV64_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
v.Op = ssaop.OpRISCV64FMOVDconst
return true
case ssaop.OpConst8:
- return rewriteValueRISCV64_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueRISCV64_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueRISCV64_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCopysign:
v.Op = ssaop.OpRISCV64FSGNJD
return true
case ssaop.OpCtz16:
- return rewriteValueRISCV64_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz64
return true
@@ -177,7 +177,7 @@
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz8:
- return rewriteValueRISCV64_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz64
return true
@@ -215,11 +215,11 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueRISCV64_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueRISCV64_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueRISCV64_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpRISCV64FDIVS
return true
@@ -227,7 +227,7 @@
v.Op = ssaop.OpRISCV64DIVUW
return true
case ssaop.OpDiv64:
- return rewriteValueRISCV64_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpRISCV64FDIVD
return true
@@ -235,27 +235,27 @@
v.Op = ssaop.OpRISCV64DIVU
return true
case ssaop.OpDiv8:
- return rewriteValueRISCV64_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueRISCV64_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueRISCV64_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueRISCV64_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
v.Op = ssaop.OpRISCV64FEQS
return true
case ssaop.OpEq64:
- return rewriteValueRISCV64_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
v.Op = ssaop.OpRISCV64FEQD
return true
case ssaop.OpEq8:
- return rewriteValueRISCV64_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueRISCV64_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueRISCV64_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpFMA:
v.Op = ssaop.OpRISCV64FMADDD
return true
@@ -269,9 +269,9 @@
v.Op = ssaop.OpRISCV64LoweredGetClosurePtr
return true
case ssaop.OpHmul32:
- return rewriteValueRISCV64_OpHmul32(v)
+ return rewriteValue_OpHmul32(v)
case ssaop.OpHmul32u:
- return rewriteValueRISCV64_OpHmul32u(v)
+ return rewriteValue_OpHmul32u(v)
case ssaop.OpHmul64:
v.Op = ssaop.OpRISCV64MULH
return true
@@ -291,38 +291,38 @@
v.Op = ssaop.OpLeq64U
return true
case ssaop.OpLeq16:
- return rewriteValueRISCV64_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueRISCV64_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueRISCV64_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
v.Op = ssaop.OpRISCV64FLES
return true
case ssaop.OpLeq32U:
- return rewriteValueRISCV64_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueRISCV64_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
v.Op = ssaop.OpRISCV64FLED
return true
case ssaop.OpLeq64U:
- return rewriteValueRISCV64_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueRISCV64_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueRISCV64_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueRISCV64_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueRISCV64_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueRISCV64_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
v.Op = ssaop.OpRISCV64FLTS
return true
case ssaop.OpLess32U:
- return rewriteValueRISCV64_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
v.Op = ssaop.OpRISCV64SLT
return true
@@ -333,85 +333,85 @@
v.Op = ssaop.OpRISCV64SLTU
return true
case ssaop.OpLess8:
- return rewriteValueRISCV64_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueRISCV64_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueRISCV64_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueRISCV64_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueRISCV64_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueRISCV64_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueRISCV64_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueRISCV64_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueRISCV64_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueRISCV64_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueRISCV64_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueRISCV64_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueRISCV64_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueRISCV64_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueRISCV64_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueRISCV64_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueRISCV64_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueRISCV64_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueRISCV64_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueRISCV64_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMax32F:
v.Op = ssaop.OpRISCV64LoweredFMAXS
return true
case ssaop.OpMax64:
- return rewriteValueRISCV64_OpMax64(v)
+ return rewriteValue_OpMax64(v)
case ssaop.OpMax64F:
v.Op = ssaop.OpRISCV64LoweredFMAXD
return true
case ssaop.OpMax64u:
- return rewriteValueRISCV64_OpMax64u(v)
+ return rewriteValue_OpMax64u(v)
case ssaop.OpMin32F:
v.Op = ssaop.OpRISCV64LoweredFMINS
return true
case ssaop.OpMin64:
- return rewriteValueRISCV64_OpMin64(v)
+ return rewriteValue_OpMin64(v)
case ssaop.OpMin64F:
v.Op = ssaop.OpRISCV64LoweredFMIND
return true
case ssaop.OpMin64u:
- return rewriteValueRISCV64_OpMin64u(v)
+ return rewriteValue_OpMin64u(v)
case ssaop.OpMod16:
- return rewriteValueRISCV64_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueRISCV64_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueRISCV64_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
v.Op = ssaop.OpRISCV64REMUW
return true
case ssaop.OpMod64:
- return rewriteValueRISCV64_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
v.Op = ssaop.OpRISCV64REMU
return true
case ssaop.OpMod8:
- return rewriteValueRISCV64_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueRISCV64_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueRISCV64_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpRISCV64MULW
return true
@@ -455,23 +455,23 @@
v.Op = ssaop.OpRISCV64NEG
return true
case ssaop.OpNeq16:
- return rewriteValueRISCV64_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueRISCV64_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
v.Op = ssaop.OpRISCV64FNES
return true
case ssaop.OpNeq64:
- return rewriteValueRISCV64_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
v.Op = ssaop.OpRISCV64FNED
return true
case ssaop.OpNeq8:
- return rewriteValueRISCV64_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
- return rewriteValueRISCV64_OpNeqB(v)
+ return rewriteValue_OpNeqB(v)
case ssaop.OpNeqPtr:
- return rewriteValueRISCV64_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpRISCV64LoweredNilCheck
return true
@@ -479,7 +479,7 @@
v.Op = ssaop.OpRISCV64SEQZ
return true
case ssaop.OpOffPtr:
- return rewriteValueRISCV64_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpRISCV64OR
return true
@@ -499,7 +499,7 @@
v.Op = ssaop.OpRISCV64LoweredPanicBoundsRR
return true
case ssaop.OpPopCount16:
- return rewriteValueRISCV64_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
v.Op = ssaop.OpRISCV64CPOPW
return true
@@ -507,176 +507,176 @@
v.Op = ssaop.OpRISCV64CPOP
return true
case ssaop.OpPopCount8:
- return rewriteValueRISCV64_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpPubBarrier:
v.Op = ssaop.OpRISCV64LoweredPubBarrier
return true
case ssaop.OpRISCV64ADD:
- return rewriteValueRISCV64_OpRISCV64ADD(v)
+ return rewriteValue_OpRISCV64ADD(v)
case ssaop.OpRISCV64ADDI:
- return rewriteValueRISCV64_OpRISCV64ADDI(v)
+ return rewriteValue_OpRISCV64ADDI(v)
case ssaop.OpRISCV64AND:
- return rewriteValueRISCV64_OpRISCV64AND(v)
+ return rewriteValue_OpRISCV64AND(v)
case ssaop.OpRISCV64ANDI:
- return rewriteValueRISCV64_OpRISCV64ANDI(v)
+ return rewriteValue_OpRISCV64ANDI(v)
case ssaop.OpRISCV64CZEROEQZ:
- return rewriteValueRISCV64_OpRISCV64CZEROEQZ(v)
+ return rewriteValue_OpRISCV64CZEROEQZ(v)
case ssaop.OpRISCV64CZERONEZ:
- return rewriteValueRISCV64_OpRISCV64CZERONEZ(v)
+ return rewriteValue_OpRISCV64CZERONEZ(v)
case ssaop.OpRISCV64FADDD:
- return rewriteValueRISCV64_OpRISCV64FADDD(v)
+ return rewriteValue_OpRISCV64FADDD(v)
case ssaop.OpRISCV64FADDS:
- return rewriteValueRISCV64_OpRISCV64FADDS(v)
+ return rewriteValue_OpRISCV64FADDS(v)
case ssaop.OpRISCV64FCVTSD:
- return rewriteValueRISCV64_OpRISCV64FCVTSD(v)
+ return rewriteValue_OpRISCV64FCVTSD(v)
case ssaop.OpRISCV64FEQD:
- return rewriteValueRISCV64_OpRISCV64FEQD(v)
+ return rewriteValue_OpRISCV64FEQD(v)
case ssaop.OpRISCV64FLED:
- return rewriteValueRISCV64_OpRISCV64FLED(v)
+ return rewriteValue_OpRISCV64FLED(v)
case ssaop.OpRISCV64FLTD:
- return rewriteValueRISCV64_OpRISCV64FLTD(v)
+ return rewriteValue_OpRISCV64FLTD(v)
case ssaop.OpRISCV64FMADDD:
- return rewriteValueRISCV64_OpRISCV64FMADDD(v)
+ return rewriteValue_OpRISCV64FMADDD(v)
case ssaop.OpRISCV64FMADDS:
- return rewriteValueRISCV64_OpRISCV64FMADDS(v)
+ return rewriteValue_OpRISCV64FMADDS(v)
case ssaop.OpRISCV64FMOVDload:
- return rewriteValueRISCV64_OpRISCV64FMOVDload(v)
+ return rewriteValue_OpRISCV64FMOVDload(v)
case ssaop.OpRISCV64FMOVDstore:
- return rewriteValueRISCV64_OpRISCV64FMOVDstore(v)
+ return rewriteValue_OpRISCV64FMOVDstore(v)
case ssaop.OpRISCV64FMOVWload:
- return rewriteValueRISCV64_OpRISCV64FMOVWload(v)
+ return rewriteValue_OpRISCV64FMOVWload(v)
case ssaop.OpRISCV64FMOVWstore:
- return rewriteValueRISCV64_OpRISCV64FMOVWstore(v)
+ return rewriteValue_OpRISCV64FMOVWstore(v)
case ssaop.OpRISCV64FMSUBD:
- return rewriteValueRISCV64_OpRISCV64FMSUBD(v)
+ return rewriteValue_OpRISCV64FMSUBD(v)
case ssaop.OpRISCV64FMSUBS:
- return rewriteValueRISCV64_OpRISCV64FMSUBS(v)
+ return rewriteValue_OpRISCV64FMSUBS(v)
case ssaop.OpRISCV64FNED:
- return rewriteValueRISCV64_OpRISCV64FNED(v)
+ return rewriteValue_OpRISCV64FNED(v)
case ssaop.OpRISCV64FNMADDD:
- return rewriteValueRISCV64_OpRISCV64FNMADDD(v)
+ return rewriteValue_OpRISCV64FNMADDD(v)
case ssaop.OpRISCV64FNMADDS:
- return rewriteValueRISCV64_OpRISCV64FNMADDS(v)
+ return rewriteValue_OpRISCV64FNMADDS(v)
case ssaop.OpRISCV64FNMSUBD:
- return rewriteValueRISCV64_OpRISCV64FNMSUBD(v)
+ return rewriteValue_OpRISCV64FNMSUBD(v)
case ssaop.OpRISCV64FNMSUBS:
- return rewriteValueRISCV64_OpRISCV64FNMSUBS(v)
+ return rewriteValue_OpRISCV64FNMSUBS(v)
case ssaop.OpRISCV64FSUBD:
- return rewriteValueRISCV64_OpRISCV64FSUBD(v)
+ return rewriteValue_OpRISCV64FSUBD(v)
case ssaop.OpRISCV64FSUBS:
- return rewriteValueRISCV64_OpRISCV64FSUBS(v)
+ return rewriteValue_OpRISCV64FSUBS(v)
case ssaop.OpRISCV64LoweredPanicBoundsCR:
- return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsCR(v)
+ return rewriteValue_OpRISCV64LoweredPanicBoundsCR(v)
case ssaop.OpRISCV64LoweredPanicBoundsRC:
- return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRC(v)
+ return rewriteValue_OpRISCV64LoweredPanicBoundsRC(v)
case ssaop.OpRISCV64LoweredPanicBoundsRR:
- return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRR(v)
+ return rewriteValue_OpRISCV64LoweredPanicBoundsRR(v)
case ssaop.OpRISCV64MOVBUload:
- return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
+ return rewriteValue_OpRISCV64MOVBUload(v)
case ssaop.OpRISCV64MOVBUreg:
- return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
+ return rewriteValue_OpRISCV64MOVBUreg(v)
case ssaop.OpRISCV64MOVBload:
- return rewriteValueRISCV64_OpRISCV64MOVBload(v)
+ return rewriteValue_OpRISCV64MOVBload(v)
case ssaop.OpRISCV64MOVBreg:
- return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
+ return rewriteValue_OpRISCV64MOVBreg(v)
case ssaop.OpRISCV64MOVBstore:
- return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
+ return rewriteValue_OpRISCV64MOVBstore(v)
case ssaop.OpRISCV64MOVBstorezero:
- return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
+ return rewriteValue_OpRISCV64MOVBstorezero(v)
case ssaop.OpRISCV64MOVDload:
- return rewriteValueRISCV64_OpRISCV64MOVDload(v)
+ return rewriteValue_OpRISCV64MOVDload(v)
case ssaop.OpRISCV64MOVDnop:
- return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
+ return rewriteValue_OpRISCV64MOVDnop(v)
case ssaop.OpRISCV64MOVDreg:
- return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
+ return rewriteValue_OpRISCV64MOVDreg(v)
case ssaop.OpRISCV64MOVDstore:
- return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
+ return rewriteValue_OpRISCV64MOVDstore(v)
case ssaop.OpRISCV64MOVDstorezero:
- return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
+ return rewriteValue_OpRISCV64MOVDstorezero(v)
case ssaop.OpRISCV64MOVHUload:
- return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
+ return rewriteValue_OpRISCV64MOVHUload(v)
case ssaop.OpRISCV64MOVHUreg:
- return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
+ return rewriteValue_OpRISCV64MOVHUreg(v)
case ssaop.OpRISCV64MOVHload:
- return rewriteValueRISCV64_OpRISCV64MOVHload(v)
+ return rewriteValue_OpRISCV64MOVHload(v)
case ssaop.OpRISCV64MOVHreg:
- return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
+ return rewriteValue_OpRISCV64MOVHreg(v)
case ssaop.OpRISCV64MOVHstore:
- return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
+ return rewriteValue_OpRISCV64MOVHstore(v)
case ssaop.OpRISCV64MOVHstorezero:
- return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
+ return rewriteValue_OpRISCV64MOVHstorezero(v)
case ssaop.OpRISCV64MOVWUload:
- return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
+ return rewriteValue_OpRISCV64MOVWUload(v)
case ssaop.OpRISCV64MOVWUreg:
- return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
+ return rewriteValue_OpRISCV64MOVWUreg(v)
case ssaop.OpRISCV64MOVWload:
- return rewriteValueRISCV64_OpRISCV64MOVWload(v)
+ return rewriteValue_OpRISCV64MOVWload(v)
case ssaop.OpRISCV64MOVWreg:
- return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
+ return rewriteValue_OpRISCV64MOVWreg(v)
case ssaop.OpRISCV64MOVWstore:
- return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
+ return rewriteValue_OpRISCV64MOVWstore(v)
case ssaop.OpRISCV64MOVWstorezero:
- return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
+ return rewriteValue_OpRISCV64MOVWstorezero(v)
case ssaop.OpRISCV64MUL:
- return rewriteValueRISCV64_OpRISCV64MUL(v)
+ return rewriteValue_OpRISCV64MUL(v)
case ssaop.OpRISCV64MULW:
- return rewriteValueRISCV64_OpRISCV64MULW(v)
+ return rewriteValue_OpRISCV64MULW(v)
case ssaop.OpRISCV64NEG:
- return rewriteValueRISCV64_OpRISCV64NEG(v)
+ return rewriteValue_OpRISCV64NEG(v)
case ssaop.OpRISCV64NEGW:
- return rewriteValueRISCV64_OpRISCV64NEGW(v)
+ return rewriteValue_OpRISCV64NEGW(v)
case ssaop.OpRISCV64OR:
- return rewriteValueRISCV64_OpRISCV64OR(v)
+ return rewriteValue_OpRISCV64OR(v)
case ssaop.OpRISCV64ORI:
- return rewriteValueRISCV64_OpRISCV64ORI(v)
+ return rewriteValue_OpRISCV64ORI(v)
case ssaop.OpRISCV64ORN:
- return rewriteValueRISCV64_OpRISCV64ORN(v)
+ return rewriteValue_OpRISCV64ORN(v)
case ssaop.OpRISCV64ROL:
- return rewriteValueRISCV64_OpRISCV64ROL(v)
+ return rewriteValue_OpRISCV64ROL(v)
case ssaop.OpRISCV64ROLW:
- return rewriteValueRISCV64_OpRISCV64ROLW(v)
+ return rewriteValue_OpRISCV64ROLW(v)
case ssaop.OpRISCV64ROR:
- return rewriteValueRISCV64_OpRISCV64ROR(v)
+ return rewriteValue_OpRISCV64ROR(v)
case ssaop.OpRISCV64RORW:
- return rewriteValueRISCV64_OpRISCV64RORW(v)
+ return rewriteValue_OpRISCV64RORW(v)
case ssaop.OpRISCV64SEQZ:
- return rewriteValueRISCV64_OpRISCV64SEQZ(v)
+ return rewriteValue_OpRISCV64SEQZ(v)
case ssaop.OpRISCV64SLL:
- return rewriteValueRISCV64_OpRISCV64SLL(v)
+ return rewriteValue_OpRISCV64SLL(v)
case ssaop.OpRISCV64SLLI:
- return rewriteValueRISCV64_OpRISCV64SLLI(v)
+ return rewriteValue_OpRISCV64SLLI(v)
case ssaop.OpRISCV64SLLW:
- return rewriteValueRISCV64_OpRISCV64SLLW(v)
+ return rewriteValue_OpRISCV64SLLW(v)
case ssaop.OpRISCV64SLT:
- return rewriteValueRISCV64_OpRISCV64SLT(v)
+ return rewriteValue_OpRISCV64SLT(v)
case ssaop.OpRISCV64SLTI:
- return rewriteValueRISCV64_OpRISCV64SLTI(v)
+ return rewriteValue_OpRISCV64SLTI(v)
case ssaop.OpRISCV64SLTIU:
- return rewriteValueRISCV64_OpRISCV64SLTIU(v)
+ return rewriteValue_OpRISCV64SLTIU(v)
case ssaop.OpRISCV64SLTU:
- return rewriteValueRISCV64_OpRISCV64SLTU(v)
+ return rewriteValue_OpRISCV64SLTU(v)
case ssaop.OpRISCV64SNEZ:
- return rewriteValueRISCV64_OpRISCV64SNEZ(v)
+ return rewriteValue_OpRISCV64SNEZ(v)
case ssaop.OpRISCV64SRA:
- return rewriteValueRISCV64_OpRISCV64SRA(v)
+ return rewriteValue_OpRISCV64SRA(v)
case ssaop.OpRISCV64SRAI:
- return rewriteValueRISCV64_OpRISCV64SRAI(v)
+ return rewriteValue_OpRISCV64SRAI(v)
case ssaop.OpRISCV64SRAW:
- return rewriteValueRISCV64_OpRISCV64SRAW(v)
+ return rewriteValue_OpRISCV64SRAW(v)
case ssaop.OpRISCV64SRL:
- return rewriteValueRISCV64_OpRISCV64SRL(v)
+ return rewriteValue_OpRISCV64SRL(v)
case ssaop.OpRISCV64SRLI:
- return rewriteValueRISCV64_OpRISCV64SRLI(v)
+ return rewriteValue_OpRISCV64SRLI(v)
case ssaop.OpRISCV64SRLW:
- return rewriteValueRISCV64_OpRISCV64SRLW(v)
+ return rewriteValue_OpRISCV64SRLW(v)
case ssaop.OpRISCV64SUB:
- return rewriteValueRISCV64_OpRISCV64SUB(v)
+ return rewriteValue_OpRISCV64SUB(v)
case ssaop.OpRISCV64SUBW:
- return rewriteValueRISCV64_OpRISCV64SUBW(v)
+ return rewriteValue_OpRISCV64SUBW(v)
case ssaop.OpRISCV64XOR:
- return rewriteValueRISCV64_OpRISCV64XOR(v)
+ return rewriteValue_OpRISCV64XOR(v)
case ssaop.OpRotateLeft16:
- return rewriteValueRISCV64_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
v.Op = ssaop.OpRISCV64ROLW
return true
@@ -684,7 +684,7 @@
v.Op = ssaop.OpRISCV64ROL
return true
case ssaop.OpRotateLeft8:
- return rewriteValueRISCV64_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpRISCV64LoweredRound32F
return true
@@ -692,73 +692,73 @@
v.Op = ssaop.OpRISCV64LoweredRound64F
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueRISCV64_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueRISCV64_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueRISCV64_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueRISCV64_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueRISCV64_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueRISCV64_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueRISCV64_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueRISCV64_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueRISCV64_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueRISCV64_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueRISCV64_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueRISCV64_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueRISCV64_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueRISCV64_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueRISCV64_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueRISCV64_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueRISCV64_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueRISCV64_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueRISCV64_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueRISCV64_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueRISCV64_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueRISCV64_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueRISCV64_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueRISCV64_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueRISCV64_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueRISCV64_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueRISCV64_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueRISCV64_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueRISCV64_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueRISCV64_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueRISCV64_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueRISCV64_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueRISCV64_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueRISCV64_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpRISCV64MOVHreg
return true
@@ -778,7 +778,7 @@
v.Op = ssaop.OpRISCV64MOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValueRISCV64_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpRISCV64FSQRTD
return true
@@ -789,7 +789,7 @@
v.Op = ssaop.OpRISCV64CALLstatic
return true
case ssaop.OpStore:
- return rewriteValueRISCV64_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpRISCV64SUB
return true
@@ -851,7 +851,7 @@
v.Op = ssaop.OpRISCV64XOR
return true
case ssaop.OpZero:
- return rewriteValueRISCV64_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpRISCV64MOVHUreg
return true
@@ -873,7 +873,7 @@
}
return false
}
-func rewriteValueRISCV64_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVaddr {sym} [0] base)
@@ -887,7 +887,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -922,7 +922,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -943,7 +943,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -973,7 +973,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1001,7 +1001,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1016,7 +1016,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1034,7 +1034,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1052,7 +1052,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1067,7 +1067,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Bswap16 <t> x)
@@ -1083,7 +1083,7 @@
return true
}
}
-func rewriteValueRISCV64_OpBswap32(v *ssa.Value) bool {
+func rewriteValue_OpBswap32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Bswap32 <t> x)
@@ -1099,7 +1099,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCondSelect(v *ssa.Value) bool {
+func rewriteValue_OpCondSelect(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1123,7 +1123,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1133,7 +1133,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1143,7 +1143,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1153,7 +1153,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1163,7 +1163,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [val])
// result: (MOVDconst [int64(ssa.B2i(val))])
for {
@@ -1173,7 +1173,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -1182,7 +1182,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1198,7 +1198,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1214,7 +1214,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1237,7 +1237,7 @@
}
return false
}
-func rewriteValueRISCV64_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1256,7 +1256,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 x y [false])
@@ -1273,7 +1273,7 @@
}
return false
}
-func rewriteValueRISCV64_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y [false])
@@ -1290,7 +1290,7 @@
}
return false
}
-func rewriteValueRISCV64_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1309,7 +1309,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1328,7 +1328,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1349,7 +1349,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1400,7 +1400,7 @@
}
return false
}
-func rewriteValueRISCV64_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1416,7 +1416,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1437,7 +1437,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1454,7 +1454,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1471,7 +1471,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul32(v *ssa.Value) bool {
+func rewriteValue_OpHmul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1493,7 +1493,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul32u(v *ssa.Value) bool {
+func rewriteValue_OpHmul32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1515,7 +1515,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1532,7 +1532,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1549,7 +1549,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1566,7 +1566,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1583,7 +1583,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1600,7 +1600,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1617,7 +1617,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1634,7 +1634,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1651,7 +1651,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1670,7 +1670,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1689,7 +1689,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1708,7 +1708,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1727,7 +1727,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1746,7 +1746,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1765,7 +1765,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -1910,7 +1910,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1950,7 +1950,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1993,7 +1993,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2036,7 +2036,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2076,7 +2076,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2119,7 +2119,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2162,7 +2162,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2205,7 +2205,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2245,7 +2245,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2288,7 +2288,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2331,7 +2331,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2374,7 +2374,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2414,7 +2414,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2457,7 +2457,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2500,7 +2500,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2543,7 +2543,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2583,7 +2583,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2626,7 +2626,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMax64(v *ssa.Value) bool {
+func rewriteValue_OpMax64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Max64 x y)
@@ -2644,7 +2644,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMax64u(v *ssa.Value) bool {
+func rewriteValue_OpMax64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Max64u x y)
@@ -2662,7 +2662,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMin64(v *ssa.Value) bool {
+func rewriteValue_OpMin64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Min64 x y)
@@ -2680,7 +2680,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMin64u(v *ssa.Value) bool {
+func rewriteValue_OpMin64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Min64u x y)
@@ -2698,7 +2698,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2721,7 +2721,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2740,7 +2740,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32 x y [false])
@@ -2757,7 +2757,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y [false])
@@ -2774,7 +2774,7 @@
}
return false
}
-func rewriteValueRISCV64_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2793,7 +2793,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2812,7 +2812,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3143,7 +3143,7 @@
}
return false
}
-func rewriteValueRISCV64_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3160,7 +3160,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3177,7 +3177,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3194,7 +3194,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3211,7 +3211,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeqB(v *ssa.Value) bool {
+func rewriteValue_OpNeqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3228,7 +3228,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3245,7 +3245,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3289,7 +3289,7 @@
return true
}
}
-func rewriteValueRISCV64_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3304,7 +3304,7 @@
return true
}
}
-func rewriteValueRISCV64_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3319,7 +3319,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRISCV64ADD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD (MOVDconst <t> [val]) x)
@@ -3417,7 +3417,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ADDI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ADDI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDI [c] (MOVaddr [d] {s} x))
// cond: ssa.Is32Bit(c+int64(d))
@@ -3485,7 +3485,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64AND(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND (MOVDconst [val]) x)
@@ -3520,7 +3520,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ANDI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ANDI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDI [0] x)
// result: (MOVDconst [0])
@@ -3570,7 +3570,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64CZEROEQZ(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64CZEROEQZ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CZEROEQZ x (SNEZ y))
@@ -3631,7 +3631,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64CZERONEZ(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64CZERONEZ(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CZERONEZ x (SNEZ y))
@@ -3693,7 +3693,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FADDD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FADDD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDD a (FMULD x y))
@@ -3718,7 +3718,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FADDS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FADDS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS a (FMULS x y))
@@ -3743,7 +3743,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FCVTSD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FCVTSD(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FCVTSD (FABSD (FCVTDS X)))
// result: (FABSS X)
@@ -3777,7 +3777,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FEQD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FEQD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3820,7 +3820,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FLED(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FLED(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3891,7 +3891,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FLTD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FLTD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3960,7 +3960,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMADDD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMADDD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4005,7 +4005,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMADDS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMADDS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4050,7 +4050,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4119,7 +4119,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4172,7 +4172,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMOVWload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4241,7 +4241,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4294,7 +4294,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMSUBD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMSUBD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4339,7 +4339,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FMSUBS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FMSUBS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4384,7 +4384,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FNED(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FNED(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4429,7 +4429,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FNMADDD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FNMADDD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4474,7 +4474,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FNMADDS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FNMADDS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4519,7 +4519,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FNMSUBD(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4564,7 +4564,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FNMSUBS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FNMSUBS(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4609,7 +4609,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FSUBD(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FSUBD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBD a (FMULD x y))
@@ -4648,7 +4648,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64FSUBS(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64FSUBS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS a (FMULS x y))
@@ -4687,7 +4687,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64LoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVDconst [c]) mem)
@@ -4708,7 +4708,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64LoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVDconst [c]) mem)
@@ -4729,7 +4729,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64LoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4767,7 +4767,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBUload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4836,7 +4836,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBUreg x:(FLES _ _))
@@ -5095,7 +5095,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5164,7 +5164,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBreg x:(ANDI [c] y))
@@ -5241,7 +5241,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5412,7 +5412,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVBstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5462,7 +5462,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5550,7 +5550,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDnop(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVDnop(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDnop (MOVDconst [c]))
// result: (MOVDconst [c])
@@ -5565,7 +5565,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVDreg(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (MOVDreg x)
// cond: x.Uses == 1
@@ -5581,7 +5581,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5650,7 +5650,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVDstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5700,7 +5700,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHUload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5769,7 +5769,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHUreg x:(ANDI [c] y))
@@ -5885,7 +5885,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5954,7 +5954,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHreg x:(ANDI [c] y))
@@ -6075,7 +6075,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6212,7 +6212,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVHstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6262,7 +6262,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWUload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWUload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6353,7 +6353,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWUreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6493,7 +6493,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWload(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6581,7 +6581,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWreg x:(ANDI [c] y))
@@ -6878,7 +6878,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6981,7 +6981,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MOVWstorezero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7031,7 +7031,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MUL(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MUL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7103,7 +7103,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MULW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64MULW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7175,7 +7175,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64NEG(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64NEG(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (NEG (SUB x y))
@@ -7261,7 +7261,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64NEGW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64NEGW(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGW (MOVDconst [x]))
// result: (MOVDconst [int64(int32(-x))])
@@ -7276,7 +7276,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64OR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7960,7 +7960,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ORI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ORI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORI [0] x)
// result: x
@@ -8010,7 +8010,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ORN(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ORN(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x x)
@@ -8026,7 +8026,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ROL(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ROL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROL x (MOVDconst [val]))
@@ -8056,7 +8056,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ROLW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ROLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLW x (MOVDconst [val]))
@@ -8086,7 +8086,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ROR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64ROR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROR x (MOVDconst [val]))
@@ -8104,7 +8104,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64RORW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64RORW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORW x (MOVDconst [val]))
@@ -8122,7 +8122,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SEQZ(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SEQZ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8211,7 +8211,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLL(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVDconst [val]))
@@ -8229,7 +8229,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLLI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLLI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLLI [x] (MOVDconst [y]))
// cond: ssa.Is32Bit(y << uint32(x))
@@ -8284,7 +8284,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLLW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLLW x (MOVDconst [val]))
@@ -8302,7 +8302,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLT(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLT(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLT x (MOVDconst [val]))
@@ -8335,7 +8335,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLTI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLTI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLTI [x] (MOVDconst [y]))
// result: (MOVDconst [ssa.B2i(int64(y) < int64(x))])
@@ -8367,7 +8367,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLTIU(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLTIU(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLTIU [x] (MOVDconst [y]))
// result: (MOVDconst [ssa.B2i(uint64(y) < uint64(x))])
@@ -8415,7 +8415,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SLTU(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLTU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLTU x (MOVDconst [val]))
@@ -8448,7 +8448,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SNEZ(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SNEZ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8537,7 +8537,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRA(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRA(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVDconst [val]))
@@ -8555,7 +8555,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRAI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRAI(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SRAI [x] (MOVWreg y))
@@ -8648,7 +8648,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRAW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRAW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAW x (MOVDconst [val]))
@@ -8666,7 +8666,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRL(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVDconst [val]))
@@ -8684,7 +8684,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRLI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRLI(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRLI [x] (MOVWUreg y))
// cond: x >= 0 && x <= 31
@@ -8762,7 +8762,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SRLW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRLW x (MOVDconst [val]))
@@ -8780,7 +8780,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SUB(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8867,7 +8867,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64SUBW(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SUBW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBW x (MOVDconst [0]))
@@ -8895,7 +8895,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64XOR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR (MOVDconst [val]) x)
@@ -8931,7 +8931,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8961,7 +8961,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8991,7 +8991,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9038,7 +9038,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9085,7 +9085,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9130,7 +9130,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9177,7 +9177,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9226,7 +9226,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9275,7 +9275,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9322,7 +9322,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9371,7 +9371,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9414,7 +9414,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9457,7 +9457,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9497,7 +9497,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9540,7 +9540,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9585,7 +9585,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9630,7 +9630,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9672,7 +9672,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9717,7 +9717,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9760,7 +9760,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9803,7 +9803,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9843,7 +9843,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9886,7 +9886,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9931,7 +9931,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9976,7 +9976,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10018,7 +10018,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10063,7 +10063,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10110,7 +10110,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10157,7 +10157,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10202,7 +10202,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10249,7 +10249,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10298,7 +10298,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10347,7 +10347,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10394,7 +10394,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10443,7 +10443,7 @@
}
return false
}
-func rewriteValueRISCV64_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10496,7 +10496,7 @@
}
return false
}
-func rewriteValueRISCV64_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10561,7 +10561,7 @@
}
return false
}
-func rewriteValueRISCV64_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -10577,7 +10577,7 @@
return true
}
}
-func rewriteValueRISCV64_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10673,7 +10673,7 @@
}
return false
}
-func rewriteValueRISCV64_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10951,7 +10951,7 @@
}
return false
}
-func rewriteBlockRISCV64(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockRISCV64BEQ:
diff --git a/src/cmd/compile/internal/ssacompile/rewriteRISCV64latelower.go b/src/cmd/compile/internal/ssarewrite/rewriteriscv64latelower/rewriteRISCV64latelower.go
similarity index 86%
rename from src/cmd/compile/internal/ssacompile/rewriteRISCV64latelower.go
rename to src/cmd/compile/internal/ssarewrite/rewriteriscv64latelower/rewriteRISCV64latelower.go
index 64f1404..8fd6d3a 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteRISCV64latelower.go
+++ b/src/cmd/compile/internal/ssarewrite/rewriteriscv64latelower/rewriteRISCV64latelower.go
@@ -1,30 +1,30 @@
// Code generated from _gen/RISCV64latelower.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewriteriscv64latelower
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueRISCV64latelower(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpRISCV64AND:
- return rewriteValueRISCV64latelower_OpRISCV64AND(v)
+ return rewriteValue_OpRISCV64AND(v)
case ssaop.OpRISCV64NOT:
- return rewriteValueRISCV64latelower_OpRISCV64NOT(v)
+ return rewriteValue_OpRISCV64NOT(v)
case ssaop.OpRISCV64OR:
- return rewriteValueRISCV64latelower_OpRISCV64OR(v)
+ return rewriteValue_OpRISCV64OR(v)
case ssaop.OpRISCV64SLLI:
- return rewriteValueRISCV64latelower_OpRISCV64SLLI(v)
+ return rewriteValue_OpRISCV64SLLI(v)
case ssaop.OpRISCV64SRAI:
- return rewriteValueRISCV64latelower_OpRISCV64SRAI(v)
+ return rewriteValue_OpRISCV64SRAI(v)
case ssaop.OpRISCV64SRLI:
- return rewriteValueRISCV64latelower_OpRISCV64SRLI(v)
+ return rewriteValue_OpRISCV64SRLI(v)
case ssaop.OpRISCV64XOR:
- return rewriteValueRISCV64latelower_OpRISCV64XOR(v)
+ return rewriteValue_OpRISCV64XOR(v)
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64AND(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64AND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (NOT y))
@@ -44,7 +44,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64NOT(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64NOT(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NOT (XOR x y))
// result: (XNOR x y)
@@ -60,7 +60,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64OR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64OR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (NOT y))
@@ -80,7 +80,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64SLLI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SLLI(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -156,7 +156,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64SRAI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRAI(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -232,7 +232,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64SRLI(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64SRLI(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -308,7 +308,7 @@
}
return false
}
-func rewriteValueRISCV64latelower_OpRISCV64XOR(v *ssa.Value) bool {
+func rewriteValue_OpRISCV64XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (NOT y))
@@ -328,6 +328,6 @@
}
return false
}
-func rewriteBlockRISCV64latelower(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/compile/internal/ssacompile/rewriteS390X.go b/src/cmd/compile/internal/ssarewrite/rewrites390x/rewriteS390X.go
similarity index 93%
rename from src/cmd/compile/internal/ssacompile/rewriteS390X.go
rename to src/cmd/compile/internal/ssarewrite/rewrites390x/rewriteS390X.go
index f2c1cad..faaee87 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssarewrite/rewrites390x/rewriteS390X.go
@@ -1,6 +1,6 @@
// Code generated from _gen/S390X.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewrites390x
import "math"
import "cmd/compile/internal/types"
@@ -9,7 +9,7 @@
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueS390X(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAdd16:
v.Op = ssaop.OpS390XADDW
@@ -18,12 +18,12 @@
v.Op = ssaop.OpS390XADDW
return true
case ssaop.OpAdd32F:
- return rewriteValueS390X_OpAdd32F(v)
+ return rewriteValue_OpAdd32F(v)
case ssaop.OpAdd64:
v.Op = ssaop.OpS390XADD
return true
case ssaop.OpAdd64F:
- return rewriteValueS390X_OpAdd64F(v)
+ return rewriteValue_OpAdd64F(v)
case ssaop.OpAdd8:
v.Op = ssaop.OpS390XADDW
return true
@@ -31,7 +31,7 @@
v.Op = ssaop.OpS390XADD
return true
case ssaop.OpAddr:
- return rewriteValueS390X_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpS390XANDW
return true
@@ -48,59 +48,59 @@
v.Op = ssaop.OpS390XANDW
return true
case ssaop.OpAtomicAdd32:
- return rewriteValueS390X_OpAtomicAdd32(v)
+ return rewriteValue_OpAtomicAdd32(v)
case ssaop.OpAtomicAdd64:
- return rewriteValueS390X_OpAtomicAdd64(v)
+ return rewriteValue_OpAtomicAdd64(v)
case ssaop.OpAtomicAnd32:
v.Op = ssaop.OpS390XLAN
return true
case ssaop.OpAtomicAnd8:
- return rewriteValueS390X_OpAtomicAnd8(v)
+ return rewriteValue_OpAtomicAnd8(v)
case ssaop.OpAtomicCompareAndSwap32:
- return rewriteValueS390X_OpAtomicCompareAndSwap32(v)
+ return rewriteValue_OpAtomicCompareAndSwap32(v)
case ssaop.OpAtomicCompareAndSwap64:
- return rewriteValueS390X_OpAtomicCompareAndSwap64(v)
+ return rewriteValue_OpAtomicCompareAndSwap64(v)
case ssaop.OpAtomicExchange32:
- return rewriteValueS390X_OpAtomicExchange32(v)
+ return rewriteValue_OpAtomicExchange32(v)
case ssaop.OpAtomicExchange64:
- return rewriteValueS390X_OpAtomicExchange64(v)
+ return rewriteValue_OpAtomicExchange64(v)
case ssaop.OpAtomicLoad32:
- return rewriteValueS390X_OpAtomicLoad32(v)
+ return rewriteValue_OpAtomicLoad32(v)
case ssaop.OpAtomicLoad64:
- return rewriteValueS390X_OpAtomicLoad64(v)
+ return rewriteValue_OpAtomicLoad64(v)
case ssaop.OpAtomicLoad8:
- return rewriteValueS390X_OpAtomicLoad8(v)
+ return rewriteValue_OpAtomicLoad8(v)
case ssaop.OpAtomicLoadAcq32:
- return rewriteValueS390X_OpAtomicLoadAcq32(v)
+ return rewriteValue_OpAtomicLoadAcq32(v)
case ssaop.OpAtomicLoadPtr:
- return rewriteValueS390X_OpAtomicLoadPtr(v)
+ return rewriteValue_OpAtomicLoadPtr(v)
case ssaop.OpAtomicOr32:
v.Op = ssaop.OpS390XLAO
return true
case ssaop.OpAtomicOr8:
- return rewriteValueS390X_OpAtomicOr8(v)
+ return rewriteValue_OpAtomicOr8(v)
case ssaop.OpAtomicStore32:
- return rewriteValueS390X_OpAtomicStore32(v)
+ return rewriteValue_OpAtomicStore32(v)
case ssaop.OpAtomicStore64:
- return rewriteValueS390X_OpAtomicStore64(v)
+ return rewriteValue_OpAtomicStore64(v)
case ssaop.OpAtomicStore8:
- return rewriteValueS390X_OpAtomicStore8(v)
+ return rewriteValue_OpAtomicStore8(v)
case ssaop.OpAtomicStorePtrNoWB:
- return rewriteValueS390X_OpAtomicStorePtrNoWB(v)
+ return rewriteValue_OpAtomicStorePtrNoWB(v)
case ssaop.OpAtomicStoreRel32:
- return rewriteValueS390X_OpAtomicStoreRel32(v)
+ return rewriteValue_OpAtomicStoreRel32(v)
case ssaop.OpAvg64u:
- return rewriteValueS390X_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValueS390X_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueS390X_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueS390X_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueS390X_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBswap16:
- return rewriteValueS390X_OpBswap16(v)
+ return rewriteValue_OpBswap16(v)
case ssaop.OpBswap32:
v.Op = ssaop.OpS390XMOVWBR
return true
@@ -108,7 +108,7 @@
v.Op = ssaop.OpS390XMOVDBR
return true
case ssaop.OpCeil:
- return rewriteValueS390X_OpCeil(v)
+ return rewriteValue_OpCeil(v)
case ssaop.OpClosureCall:
v.Op = ssaop.OpS390XCALLclosure
return true
@@ -125,40 +125,40 @@
v.Op = ssaop.OpS390XNOTW
return true
case ssaop.OpConst16:
- return rewriteValueS390X_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueS390X_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
v.Op = ssaop.OpS390XFMOVSconst
return true
case ssaop.OpConst64:
- return rewriteValueS390X_OpConst64(v)
+ return rewriteValue_OpConst64(v)
case ssaop.OpConst64F:
v.Op = ssaop.OpS390XFMOVDconst
return true
case ssaop.OpConst8:
- return rewriteValueS390X_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueS390X_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueS390X_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpCtz16:
- return rewriteValueS390X_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz32:
- return rewriteValueS390X_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz64:
- return rewriteValueS390X_OpCtz64(v)
+ return rewriteValue_OpCtz64(v)
case ssaop.OpCtz64NonZero:
v.Op = ssaop.OpCtz64
return true
case ssaop.OpCtz8:
- return rewriteValueS390X_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpCtz64
return true
@@ -220,18 +220,18 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueS390X_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueS390X_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueS390X_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpS390XFDIVS
return true
case ssaop.OpDiv32u:
- return rewriteValueS390X_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValueS390X_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpS390XFDIV
return true
@@ -239,29 +239,29 @@
v.Op = ssaop.OpS390XDIVDU
return true
case ssaop.OpDiv8:
- return rewriteValueS390X_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueS390X_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpEq16:
- return rewriteValueS390X_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueS390X_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
- return rewriteValueS390X_OpEq32F(v)
+ return rewriteValue_OpEq32F(v)
case ssaop.OpEq64:
- return rewriteValueS390X_OpEq64(v)
+ return rewriteValue_OpEq64(v)
case ssaop.OpEq64F:
- return rewriteValueS390X_OpEq64F(v)
+ return rewriteValue_OpEq64F(v)
case ssaop.OpEq8:
- return rewriteValueS390X_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
- return rewriteValueS390X_OpEqB(v)
+ return rewriteValue_OpEqB(v)
case ssaop.OpEqPtr:
- return rewriteValueS390X_OpEqPtr(v)
+ return rewriteValue_OpEqPtr(v)
case ssaop.OpFMA:
- return rewriteValueS390X_OpFMA(v)
+ return rewriteValue_OpFMA(v)
case ssaop.OpFloor:
- return rewriteValueS390X_OpFloor(v)
+ return rewriteValue_OpFloor(v)
case ssaop.OpGetCallerPC:
v.Op = ssaop.OpS390XLoweredGetCallerPC
return true
@@ -275,9 +275,9 @@
v.Op = ssaop.OpS390XLoweredGetG
return true
case ssaop.OpHmul32:
- return rewriteValueS390X_OpHmul32(v)
+ return rewriteValue_OpHmul32(v)
case ssaop.OpHmul32u:
- return rewriteValueS390X_OpHmul32u(v)
+ return rewriteValue_OpHmul32u(v)
case ssaop.OpHmul64:
v.Op = ssaop.OpS390XMULHD
return true
@@ -285,92 +285,92 @@
v.Op = ssaop.OpS390XMULHDU
return true
case ssaop.OpITab:
- return rewriteValueS390X_OpITab(v)
+ return rewriteValue_OpITab(v)
case ssaop.OpInterCall:
v.Op = ssaop.OpS390XCALLinter
return true
case ssaop.OpIsInBounds:
- return rewriteValueS390X_OpIsInBounds(v)
+ return rewriteValue_OpIsInBounds(v)
case ssaop.OpIsNonNil:
- return rewriteValueS390X_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
- return rewriteValueS390X_OpIsSliceInBounds(v)
+ return rewriteValue_OpIsSliceInBounds(v)
case ssaop.OpLeq16:
- return rewriteValueS390X_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueS390X_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueS390X_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
- return rewriteValueS390X_OpLeq32F(v)
+ return rewriteValue_OpLeq32F(v)
case ssaop.OpLeq32U:
- return rewriteValueS390X_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
- return rewriteValueS390X_OpLeq64(v)
+ return rewriteValue_OpLeq64(v)
case ssaop.OpLeq64F:
- return rewriteValueS390X_OpLeq64F(v)
+ return rewriteValue_OpLeq64F(v)
case ssaop.OpLeq64U:
- return rewriteValueS390X_OpLeq64U(v)
+ return rewriteValue_OpLeq64U(v)
case ssaop.OpLeq8:
- return rewriteValueS390X_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueS390X_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueS390X_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueS390X_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueS390X_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
- return rewriteValueS390X_OpLess32F(v)
+ return rewriteValue_OpLess32F(v)
case ssaop.OpLess32U:
- return rewriteValueS390X_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
- return rewriteValueS390X_OpLess64(v)
+ return rewriteValue_OpLess64(v)
case ssaop.OpLess64F:
- return rewriteValueS390X_OpLess64F(v)
+ return rewriteValue_OpLess64F(v)
case ssaop.OpLess64U:
- return rewriteValueS390X_OpLess64U(v)
+ return rewriteValue_OpLess64U(v)
case ssaop.OpLess8:
- return rewriteValueS390X_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueS390X_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLoad:
- return rewriteValueS390X_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueS390X_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLsh16x16:
- return rewriteValueS390X_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueS390X_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
- return rewriteValueS390X_OpLsh16x64(v)
+ return rewriteValue_OpLsh16x64(v)
case ssaop.OpLsh16x8:
- return rewriteValueS390X_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueS390X_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueS390X_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
- return rewriteValueS390X_OpLsh32x64(v)
+ return rewriteValue_OpLsh32x64(v)
case ssaop.OpLsh32x8:
- return rewriteValueS390X_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueS390X_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueS390X_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueS390X_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueS390X_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueS390X_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueS390X_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
- return rewriteValueS390X_OpLsh8x64(v)
+ return rewriteValue_OpLsh8x64(v)
case ssaop.OpLsh8x8:
- return rewriteValueS390X_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMax32F:
v.Op = ssaop.OpS390XWFMAXSB
return true
@@ -384,24 +384,24 @@
v.Op = ssaop.OpS390XWFMINDB
return true
case ssaop.OpMod16:
- return rewriteValueS390X_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueS390X_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueS390X_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueS390X_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValueS390X_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
v.Op = ssaop.OpS390XMODDU
return true
case ssaop.OpMod8:
- return rewriteValueS390X_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueS390X_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueS390X_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpS390XMULLW
return true
@@ -442,28 +442,28 @@
v.Op = ssaop.OpS390XNEGW
return true
case ssaop.OpNeq16:
- return rewriteValueS390X_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueS390X_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
- return rewriteValueS390X_OpNeq32F(v)
+ return rewriteValue_OpNeq32F(v)
case ssaop.OpNeq64:
- return rewriteValueS390X_OpNeq64(v)
+ return rewriteValue_OpNeq64(v)
case ssaop.OpNeq64F:
- return rewriteValueS390X_OpNeq64F(v)
+ return rewriteValue_OpNeq64F(v)
case ssaop.OpNeq8:
- return rewriteValueS390X_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
- return rewriteValueS390X_OpNeqB(v)
+ return rewriteValue_OpNeqB(v)
case ssaop.OpNeqPtr:
- return rewriteValueS390X_OpNeqPtr(v)
+ return rewriteValue_OpNeqPtr(v)
case ssaop.OpNilCheck:
v.Op = ssaop.OpS390XLoweredNilCheck
return true
case ssaop.OpNot:
- return rewriteValueS390X_OpNot(v)
+ return rewriteValue_OpNot(v)
case ssaop.OpOffPtr:
- return rewriteValueS390X_OpOffPtr(v)
+ return rewriteValue_OpOffPtr(v)
case ssaop.OpOr16:
v.Op = ssaop.OpS390XORW
return true
@@ -483,15 +483,15 @@
v.Op = ssaop.OpS390XLoweredPanicBoundsRR
return true
case ssaop.OpPopCount16:
- return rewriteValueS390X_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValueS390X_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
- return rewriteValueS390X_OpPopCount64(v)
+ return rewriteValue_OpPopCount64(v)
case ssaop.OpPopCount8:
- return rewriteValueS390X_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpRotateLeft16:
- return rewriteValueS390X_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
v.Op = ssaop.OpS390XRLL
return true
@@ -499,9 +499,9 @@
v.Op = ssaop.OpS390XRLLG
return true
case ssaop.OpRotateLeft8:
- return rewriteValueS390X_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound:
- return rewriteValueS390X_OpRound(v)
+ return rewriteValue_OpRound(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpS390XLoweredRound32F
return true
@@ -509,311 +509,311 @@
v.Op = ssaop.OpS390XLoweredRound64F
return true
case ssaop.OpRoundToEven:
- return rewriteValueS390X_OpRoundToEven(v)
+ return rewriteValue_OpRoundToEven(v)
case ssaop.OpRsh16Ux16:
- return rewriteValueS390X_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueS390X_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueS390X_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueS390X_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueS390X_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueS390X_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueS390X_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueS390X_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueS390X_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueS390X_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueS390X_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueS390X_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueS390X_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueS390X_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueS390X_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueS390X_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueS390X_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueS390X_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueS390X_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueS390X_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueS390X_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueS390X_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueS390X_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueS390X_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueS390X_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueS390X_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueS390X_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueS390X_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueS390X_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueS390X_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueS390X_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueS390X_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpS390XADD:
- return rewriteValueS390X_OpS390XADD(v)
+ return rewriteValue_OpS390XADD(v)
case ssaop.OpS390XADDC:
- return rewriteValueS390X_OpS390XADDC(v)
+ return rewriteValue_OpS390XADDC(v)
case ssaop.OpS390XADDE:
- return rewriteValueS390X_OpS390XADDE(v)
+ return rewriteValue_OpS390XADDE(v)
case ssaop.OpS390XADDW:
- return rewriteValueS390X_OpS390XADDW(v)
+ return rewriteValue_OpS390XADDW(v)
case ssaop.OpS390XADDWconst:
- return rewriteValueS390X_OpS390XADDWconst(v)
+ return rewriteValue_OpS390XADDWconst(v)
case ssaop.OpS390XADDWload:
- return rewriteValueS390X_OpS390XADDWload(v)
+ return rewriteValue_OpS390XADDWload(v)
case ssaop.OpS390XADDconst:
- return rewriteValueS390X_OpS390XADDconst(v)
+ return rewriteValue_OpS390XADDconst(v)
case ssaop.OpS390XADDload:
- return rewriteValueS390X_OpS390XADDload(v)
+ return rewriteValue_OpS390XADDload(v)
case ssaop.OpS390XAND:
- return rewriteValueS390X_OpS390XAND(v)
+ return rewriteValue_OpS390XAND(v)
case ssaop.OpS390XANDW:
- return rewriteValueS390X_OpS390XANDW(v)
+ return rewriteValue_OpS390XANDW(v)
case ssaop.OpS390XANDWconst:
- return rewriteValueS390X_OpS390XANDWconst(v)
+ return rewriteValue_OpS390XANDWconst(v)
case ssaop.OpS390XANDWload:
- return rewriteValueS390X_OpS390XANDWload(v)
+ return rewriteValue_OpS390XANDWload(v)
case ssaop.OpS390XANDconst:
- return rewriteValueS390X_OpS390XANDconst(v)
+ return rewriteValue_OpS390XANDconst(v)
case ssaop.OpS390XANDload:
- return rewriteValueS390X_OpS390XANDload(v)
+ return rewriteValue_OpS390XANDload(v)
case ssaop.OpS390XCMP:
- return rewriteValueS390X_OpS390XCMP(v)
+ return rewriteValue_OpS390XCMP(v)
case ssaop.OpS390XCMPU:
- return rewriteValueS390X_OpS390XCMPU(v)
+ return rewriteValue_OpS390XCMPU(v)
case ssaop.OpS390XCMPUconst:
- return rewriteValueS390X_OpS390XCMPUconst(v)
+ return rewriteValue_OpS390XCMPUconst(v)
case ssaop.OpS390XCMPW:
- return rewriteValueS390X_OpS390XCMPW(v)
+ return rewriteValue_OpS390XCMPW(v)
case ssaop.OpS390XCMPWU:
- return rewriteValueS390X_OpS390XCMPWU(v)
+ return rewriteValue_OpS390XCMPWU(v)
case ssaop.OpS390XCMPWUconst:
- return rewriteValueS390X_OpS390XCMPWUconst(v)
+ return rewriteValue_OpS390XCMPWUconst(v)
case ssaop.OpS390XCMPWconst:
- return rewriteValueS390X_OpS390XCMPWconst(v)
+ return rewriteValue_OpS390XCMPWconst(v)
case ssaop.OpS390XCMPconst:
- return rewriteValueS390X_OpS390XCMPconst(v)
+ return rewriteValue_OpS390XCMPconst(v)
case ssaop.OpS390XCPSDR:
- return rewriteValueS390X_OpS390XCPSDR(v)
+ return rewriteValue_OpS390XCPSDR(v)
case ssaop.OpS390XFCMP:
- return rewriteValueS390X_OpS390XFCMP(v)
+ return rewriteValue_OpS390XFCMP(v)
case ssaop.OpS390XFCMPS:
- return rewriteValueS390X_OpS390XFCMPS(v)
+ return rewriteValue_OpS390XFCMPS(v)
case ssaop.OpS390XFMOVDload:
- return rewriteValueS390X_OpS390XFMOVDload(v)
+ return rewriteValue_OpS390XFMOVDload(v)
case ssaop.OpS390XFMOVDstore:
- return rewriteValueS390X_OpS390XFMOVDstore(v)
+ return rewriteValue_OpS390XFMOVDstore(v)
case ssaop.OpS390XFMOVSload:
- return rewriteValueS390X_OpS390XFMOVSload(v)
+ return rewriteValue_OpS390XFMOVSload(v)
case ssaop.OpS390XFMOVSstore:
- return rewriteValueS390X_OpS390XFMOVSstore(v)
+ return rewriteValue_OpS390XFMOVSstore(v)
case ssaop.OpS390XFNEG:
- return rewriteValueS390X_OpS390XFNEG(v)
+ return rewriteValue_OpS390XFNEG(v)
case ssaop.OpS390XFNEGS:
- return rewriteValueS390X_OpS390XFNEGS(v)
+ return rewriteValue_OpS390XFNEGS(v)
case ssaop.OpS390XLDGR:
- return rewriteValueS390X_OpS390XLDGR(v)
+ return rewriteValue_OpS390XLDGR(v)
case ssaop.OpS390XLEDBR:
- return rewriteValueS390X_OpS390XLEDBR(v)
+ return rewriteValue_OpS390XLEDBR(v)
case ssaop.OpS390XLGDR:
- return rewriteValueS390X_OpS390XLGDR(v)
+ return rewriteValue_OpS390XLGDR(v)
case ssaop.OpS390XLOCGR:
- return rewriteValueS390X_OpS390XLOCGR(v)
+ return rewriteValue_OpS390XLOCGR(v)
case ssaop.OpS390XLTDBR:
- return rewriteValueS390X_OpS390XLTDBR(v)
+ return rewriteValue_OpS390XLTDBR(v)
case ssaop.OpS390XLTEBR:
- return rewriteValueS390X_OpS390XLTEBR(v)
+ return rewriteValue_OpS390XLTEBR(v)
case ssaop.OpS390XLoweredPanicBoundsCR:
- return rewriteValueS390X_OpS390XLoweredPanicBoundsCR(v)
+ return rewriteValue_OpS390XLoweredPanicBoundsCR(v)
case ssaop.OpS390XLoweredPanicBoundsRC:
- return rewriteValueS390X_OpS390XLoweredPanicBoundsRC(v)
+ return rewriteValue_OpS390XLoweredPanicBoundsRC(v)
case ssaop.OpS390XLoweredPanicBoundsRR:
- return rewriteValueS390X_OpS390XLoweredPanicBoundsRR(v)
+ return rewriteValue_OpS390XLoweredPanicBoundsRR(v)
case ssaop.OpS390XLoweredRound32F:
- return rewriteValueS390X_OpS390XLoweredRound32F(v)
+ return rewriteValue_OpS390XLoweredRound32F(v)
case ssaop.OpS390XLoweredRound64F:
- return rewriteValueS390X_OpS390XLoweredRound64F(v)
+ return rewriteValue_OpS390XLoweredRound64F(v)
case ssaop.OpS390XMOVBZload:
- return rewriteValueS390X_OpS390XMOVBZload(v)
+ return rewriteValue_OpS390XMOVBZload(v)
case ssaop.OpS390XMOVBZreg:
- return rewriteValueS390X_OpS390XMOVBZreg(v)
+ return rewriteValue_OpS390XMOVBZreg(v)
case ssaop.OpS390XMOVBload:
- return rewriteValueS390X_OpS390XMOVBload(v)
+ return rewriteValue_OpS390XMOVBload(v)
case ssaop.OpS390XMOVBreg:
- return rewriteValueS390X_OpS390XMOVBreg(v)
+ return rewriteValue_OpS390XMOVBreg(v)
case ssaop.OpS390XMOVBstore:
- return rewriteValueS390X_OpS390XMOVBstore(v)
+ return rewriteValue_OpS390XMOVBstore(v)
case ssaop.OpS390XMOVBstoreconst:
- return rewriteValueS390X_OpS390XMOVBstoreconst(v)
+ return rewriteValue_OpS390XMOVBstoreconst(v)
case ssaop.OpS390XMOVDBR:
- return rewriteValueS390X_OpS390XMOVDBR(v)
+ return rewriteValue_OpS390XMOVDBR(v)
case ssaop.OpS390XMOVDaddridx:
- return rewriteValueS390X_OpS390XMOVDaddridx(v)
+ return rewriteValue_OpS390XMOVDaddridx(v)
case ssaop.OpS390XMOVDload:
- return rewriteValueS390X_OpS390XMOVDload(v)
+ return rewriteValue_OpS390XMOVDload(v)
case ssaop.OpS390XMOVDstore:
- return rewriteValueS390X_OpS390XMOVDstore(v)
+ return rewriteValue_OpS390XMOVDstore(v)
case ssaop.OpS390XMOVDstoreconst:
- return rewriteValueS390X_OpS390XMOVDstoreconst(v)
+ return rewriteValue_OpS390XMOVDstoreconst(v)
case ssaop.OpS390XMOVDstoreidx:
- return rewriteValueS390X_OpS390XMOVDstoreidx(v)
+ return rewriteValue_OpS390XMOVDstoreidx(v)
case ssaop.OpS390XMOVHZload:
- return rewriteValueS390X_OpS390XMOVHZload(v)
+ return rewriteValue_OpS390XMOVHZload(v)
case ssaop.OpS390XMOVHZreg:
- return rewriteValueS390X_OpS390XMOVHZreg(v)
+ return rewriteValue_OpS390XMOVHZreg(v)
case ssaop.OpS390XMOVHload:
- return rewriteValueS390X_OpS390XMOVHload(v)
+ return rewriteValue_OpS390XMOVHload(v)
case ssaop.OpS390XMOVHreg:
- return rewriteValueS390X_OpS390XMOVHreg(v)
+ return rewriteValue_OpS390XMOVHreg(v)
case ssaop.OpS390XMOVHstore:
- return rewriteValueS390X_OpS390XMOVHstore(v)
+ return rewriteValue_OpS390XMOVHstore(v)
case ssaop.OpS390XMOVHstoreconst:
- return rewriteValueS390X_OpS390XMOVHstoreconst(v)
+ return rewriteValue_OpS390XMOVHstoreconst(v)
case ssaop.OpS390XMOVHstoreidx:
- return rewriteValueS390X_OpS390XMOVHstoreidx(v)
+ return rewriteValue_OpS390XMOVHstoreidx(v)
case ssaop.OpS390XMOVWBR:
- return rewriteValueS390X_OpS390XMOVWBR(v)
+ return rewriteValue_OpS390XMOVWBR(v)
case ssaop.OpS390XMOVWZload:
- return rewriteValueS390X_OpS390XMOVWZload(v)
+ return rewriteValue_OpS390XMOVWZload(v)
case ssaop.OpS390XMOVWZreg:
- return rewriteValueS390X_OpS390XMOVWZreg(v)
+ return rewriteValue_OpS390XMOVWZreg(v)
case ssaop.OpS390XMOVWload:
- return rewriteValueS390X_OpS390XMOVWload(v)
+ return rewriteValue_OpS390XMOVWload(v)
case ssaop.OpS390XMOVWreg:
- return rewriteValueS390X_OpS390XMOVWreg(v)
+ return rewriteValue_OpS390XMOVWreg(v)
case ssaop.OpS390XMOVWstore:
- return rewriteValueS390X_OpS390XMOVWstore(v)
+ return rewriteValue_OpS390XMOVWstore(v)
case ssaop.OpS390XMOVWstoreconst:
- return rewriteValueS390X_OpS390XMOVWstoreconst(v)
+ return rewriteValue_OpS390XMOVWstoreconst(v)
case ssaop.OpS390XMOVWstoreidx:
- return rewriteValueS390X_OpS390XMOVWstoreidx(v)
+ return rewriteValue_OpS390XMOVWstoreidx(v)
case ssaop.OpS390XMULLD:
- return rewriteValueS390X_OpS390XMULLD(v)
+ return rewriteValue_OpS390XMULLD(v)
case ssaop.OpS390XMULLDconst:
- return rewriteValueS390X_OpS390XMULLDconst(v)
+ return rewriteValue_OpS390XMULLDconst(v)
case ssaop.OpS390XMULLDload:
- return rewriteValueS390X_OpS390XMULLDload(v)
+ return rewriteValue_OpS390XMULLDload(v)
case ssaop.OpS390XMULLW:
- return rewriteValueS390X_OpS390XMULLW(v)
+ return rewriteValue_OpS390XMULLW(v)
case ssaop.OpS390XMULLWconst:
- return rewriteValueS390X_OpS390XMULLWconst(v)
+ return rewriteValue_OpS390XMULLWconst(v)
case ssaop.OpS390XMULLWload:
- return rewriteValueS390X_OpS390XMULLWload(v)
+ return rewriteValue_OpS390XMULLWload(v)
case ssaop.OpS390XNEG:
- return rewriteValueS390X_OpS390XNEG(v)
+ return rewriteValue_OpS390XNEG(v)
case ssaop.OpS390XNEGW:
- return rewriteValueS390X_OpS390XNEGW(v)
+ return rewriteValue_OpS390XNEGW(v)
case ssaop.OpS390XNOT:
- return rewriteValueS390X_OpS390XNOT(v)
+ return rewriteValue_OpS390XNOT(v)
case ssaop.OpS390XNOTW:
- return rewriteValueS390X_OpS390XNOTW(v)
+ return rewriteValue_OpS390XNOTW(v)
case ssaop.OpS390XOR:
- return rewriteValueS390X_OpS390XOR(v)
+ return rewriteValue_OpS390XOR(v)
case ssaop.OpS390XORW:
- return rewriteValueS390X_OpS390XORW(v)
+ return rewriteValue_OpS390XORW(v)
case ssaop.OpS390XORWconst:
- return rewriteValueS390X_OpS390XORWconst(v)
+ return rewriteValue_OpS390XORWconst(v)
case ssaop.OpS390XORWload:
- return rewriteValueS390X_OpS390XORWload(v)
+ return rewriteValue_OpS390XORWload(v)
case ssaop.OpS390XORconst:
- return rewriteValueS390X_OpS390XORconst(v)
+ return rewriteValue_OpS390XORconst(v)
case ssaop.OpS390XORload:
- return rewriteValueS390X_OpS390XORload(v)
+ return rewriteValue_OpS390XORload(v)
case ssaop.OpS390XRISBGZ:
- return rewriteValueS390X_OpS390XRISBGZ(v)
+ return rewriteValue_OpS390XRISBGZ(v)
case ssaop.OpS390XRLL:
- return rewriteValueS390X_OpS390XRLL(v)
+ return rewriteValue_OpS390XRLL(v)
case ssaop.OpS390XRLLG:
- return rewriteValueS390X_OpS390XRLLG(v)
+ return rewriteValue_OpS390XRLLG(v)
case ssaop.OpS390XSLD:
- return rewriteValueS390X_OpS390XSLD(v)
+ return rewriteValue_OpS390XSLD(v)
case ssaop.OpS390XSLDconst:
- return rewriteValueS390X_OpS390XSLDconst(v)
+ return rewriteValue_OpS390XSLDconst(v)
case ssaop.OpS390XSLW:
- return rewriteValueS390X_OpS390XSLW(v)
+ return rewriteValue_OpS390XSLW(v)
case ssaop.OpS390XSLWconst:
- return rewriteValueS390X_OpS390XSLWconst(v)
+ return rewriteValue_OpS390XSLWconst(v)
case ssaop.OpS390XSRAD:
- return rewriteValueS390X_OpS390XSRAD(v)
+ return rewriteValue_OpS390XSRAD(v)
case ssaop.OpS390XSRADconst:
- return rewriteValueS390X_OpS390XSRADconst(v)
+ return rewriteValue_OpS390XSRADconst(v)
case ssaop.OpS390XSRAW:
- return rewriteValueS390X_OpS390XSRAW(v)
+ return rewriteValue_OpS390XSRAW(v)
case ssaop.OpS390XSRAWconst:
- return rewriteValueS390X_OpS390XSRAWconst(v)
+ return rewriteValue_OpS390XSRAWconst(v)
case ssaop.OpS390XSRD:
- return rewriteValueS390X_OpS390XSRD(v)
+ return rewriteValue_OpS390XSRD(v)
case ssaop.OpS390XSRDconst:
- return rewriteValueS390X_OpS390XSRDconst(v)
+ return rewriteValue_OpS390XSRDconst(v)
case ssaop.OpS390XSRW:
- return rewriteValueS390X_OpS390XSRW(v)
+ return rewriteValue_OpS390XSRW(v)
case ssaop.OpS390XSRWconst:
- return rewriteValueS390X_OpS390XSRWconst(v)
+ return rewriteValue_OpS390XSRWconst(v)
case ssaop.OpS390XSTM2:
- return rewriteValueS390X_OpS390XSTM2(v)
+ return rewriteValue_OpS390XSTM2(v)
case ssaop.OpS390XSTMG2:
- return rewriteValueS390X_OpS390XSTMG2(v)
+ return rewriteValue_OpS390XSTMG2(v)
case ssaop.OpS390XSUB:
- return rewriteValueS390X_OpS390XSUB(v)
+ return rewriteValue_OpS390XSUB(v)
case ssaop.OpS390XSUBE:
- return rewriteValueS390X_OpS390XSUBE(v)
+ return rewriteValue_OpS390XSUBE(v)
case ssaop.OpS390XSUBW:
- return rewriteValueS390X_OpS390XSUBW(v)
+ return rewriteValue_OpS390XSUBW(v)
case ssaop.OpS390XSUBWconst:
- return rewriteValueS390X_OpS390XSUBWconst(v)
+ return rewriteValue_OpS390XSUBWconst(v)
case ssaop.OpS390XSUBWload:
- return rewriteValueS390X_OpS390XSUBWload(v)
+ return rewriteValue_OpS390XSUBWload(v)
case ssaop.OpS390XSUBconst:
- return rewriteValueS390X_OpS390XSUBconst(v)
+ return rewriteValue_OpS390XSUBconst(v)
case ssaop.OpS390XSUBload:
- return rewriteValueS390X_OpS390XSUBload(v)
+ return rewriteValue_OpS390XSUBload(v)
case ssaop.OpS390XSumBytes2:
- return rewriteValueS390X_OpS390XSumBytes2(v)
+ return rewriteValue_OpS390XSumBytes2(v)
case ssaop.OpS390XSumBytes4:
- return rewriteValueS390X_OpS390XSumBytes4(v)
+ return rewriteValue_OpS390XSumBytes4(v)
case ssaop.OpS390XSumBytes8:
- return rewriteValueS390X_OpS390XSumBytes8(v)
+ return rewriteValue_OpS390XSumBytes8(v)
case ssaop.OpS390XXOR:
- return rewriteValueS390X_OpS390XXOR(v)
+ return rewriteValue_OpS390XXOR(v)
case ssaop.OpS390XXORW:
- return rewriteValueS390X_OpS390XXORW(v)
+ return rewriteValue_OpS390XXORW(v)
case ssaop.OpS390XXORWconst:
- return rewriteValueS390X_OpS390XXORWconst(v)
+ return rewriteValue_OpS390XXORWconst(v)
case ssaop.OpS390XXORWload:
- return rewriteValueS390X_OpS390XXORWload(v)
+ return rewriteValue_OpS390XXORWload(v)
case ssaop.OpS390XXORconst:
- return rewriteValueS390X_OpS390XXORconst(v)
+ return rewriteValue_OpS390XXORconst(v)
case ssaop.OpS390XXORload:
- return rewriteValueS390X_OpS390XXORload(v)
+ return rewriteValue_OpS390XXORload(v)
case ssaop.OpSelect0:
- return rewriteValueS390X_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueS390X_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSignExt16to32:
v.Op = ssaop.OpS390XMOVHreg
return true
@@ -833,7 +833,7 @@
v.Op = ssaop.OpS390XMOVBreg
return true
case ssaop.OpSlicemask:
- return rewriteValueS390X_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpS390XFSQRT
return true
@@ -844,7 +844,7 @@
v.Op = ssaop.OpS390XCALLstatic
return true
case ssaop.OpStore:
- return rewriteValueS390X_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpS390XSUBW
return true
@@ -852,12 +852,12 @@
v.Op = ssaop.OpS390XSUBW
return true
case ssaop.OpSub32F:
- return rewriteValueS390X_OpSub32F(v)
+ return rewriteValue_OpSub32F(v)
case ssaop.OpSub64:
v.Op = ssaop.OpS390XSUB
return true
case ssaop.OpSub64F:
- return rewriteValueS390X_OpSub64F(v)
+ return rewriteValue_OpSub64F(v)
case ssaop.OpSub8:
v.Op = ssaop.OpS390XSUBW
return true
@@ -871,7 +871,7 @@
v.Op = ssaop.OpS390XCALLtailinter
return true
case ssaop.OpTrunc:
- return rewriteValueS390X_OpTrunc(v)
+ return rewriteValue_OpTrunc(v)
case ssaop.OpTrunc16to8:
v.Op = ssaop.OpCopy
return true
@@ -906,7 +906,7 @@
v.Op = ssaop.OpS390XXORW
return true
case ssaop.OpZero:
- return rewriteValueS390X_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
v.Op = ssaop.OpS390XMOVHZreg
return true
@@ -928,7 +928,7 @@
}
return false
}
-func rewriteValueS390X_OpAdd32F(v *ssa.Value) bool {
+func rewriteValue_OpAdd32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -945,7 +945,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd64F(v *ssa.Value) bool {
+func rewriteValue_OpAdd64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -962,7 +962,7 @@
return true
}
}
-func rewriteValueS390X_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} base)
@@ -975,7 +975,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAdd32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -994,7 +994,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAdd64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1013,7 +1013,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAnd8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicAnd8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1040,7 +1040,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap32(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1057,7 +1057,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicCompareAndSwap64(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1074,7 +1074,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicExchange32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1089,7 +1089,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicExchange64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1104,7 +1104,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -1117,7 +1117,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -1130,7 +1130,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoad8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -1143,7 +1143,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoadAcq32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadAcq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadAcq32 ptr mem)
@@ -1156,7 +1156,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoadPtr(v *ssa.Value) bool {
+func rewriteValue_OpAtomicLoadPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -1169,7 +1169,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicOr8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicOr8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1195,7 +1195,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1213,7 +1213,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore64(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore64(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1231,7 +1231,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore8(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStore8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1249,7 +1249,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStorePtrNoWB(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStorePtrNoWB(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1267,7 +1267,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStoreRel32(v *ssa.Value) bool {
+func rewriteValue_OpAtomicStoreRel32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1282,7 +1282,7 @@
return true
}
}
-func rewriteValueS390X_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1302,7 +1302,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1317,7 +1317,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1332,7 +1332,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1349,7 +1349,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1364,7 +1364,7 @@
return true
}
}
-func rewriteValueS390X_OpBswap16(v *ssa.Value) bool {
+func rewriteValue_OpBswap16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1413,7 +1413,7 @@
}
return false
}
-func rewriteValueS390X_OpCeil(v *ssa.Value) bool {
+func rewriteValue_OpCeil(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (FIDBR [6] x)
@@ -1425,7 +1425,7 @@
return true
}
}
-func rewriteValueS390X_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1435,7 +1435,7 @@
return true
}
}
-func rewriteValueS390X_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1445,7 +1445,7 @@
return true
}
}
-func rewriteValueS390X_OpConst64(v *ssa.Value) bool {
+func rewriteValue_OpConst64(v *ssa.Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1455,7 +1455,7 @@
return true
}
}
-func rewriteValueS390X_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [int64(val)])
for {
@@ -1465,7 +1465,7 @@
return true
}
}
-func rewriteValueS390X_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [t])
// result: (MOVDconst [ssa.B2i(t)])
for {
@@ -1475,7 +1475,7 @@
return true
}
}
-func rewriteValueS390X_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -1484,7 +1484,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1501,7 +1501,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1528,7 +1528,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz64(v *ssa.Value) bool {
+func rewriteValue_OpCtz64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1553,7 +1553,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1570,7 +1570,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1589,7 +1589,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1608,7 +1608,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1625,7 +1625,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1642,7 +1642,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1655,7 +1655,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1674,7 +1674,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1693,7 +1693,7 @@
return true
}
}
-func rewriteValueS390X_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1719,7 +1719,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1741,7 +1741,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32F(v *ssa.Value) bool {
+func rewriteValue_OpEq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1763,7 +1763,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64(v *ssa.Value) bool {
+func rewriteValue_OpEq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1785,7 +1785,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64F(v *ssa.Value) bool {
+func rewriteValue_OpEq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1807,7 +1807,7 @@
return true
}
}
-func rewriteValueS390X_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1833,7 +1833,7 @@
return true
}
}
-func rewriteValueS390X_OpEqB(v *ssa.Value) bool {
+func rewriteValue_OpEqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1859,7 +1859,7 @@
return true
}
}
-func rewriteValueS390X_OpEqPtr(v *ssa.Value) bool {
+func rewriteValue_OpEqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1881,7 +1881,7 @@
return true
}
}
-func rewriteValueS390X_OpFMA(v *ssa.Value) bool {
+func rewriteValue_OpFMA(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1896,7 +1896,7 @@
return true
}
}
-func rewriteValueS390X_OpFloor(v *ssa.Value) bool {
+func rewriteValue_OpFloor(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (FIDBR [7] x)
@@ -1908,7 +1908,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32(v *ssa.Value) bool {
+func rewriteValue_OpHmul32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1930,7 +1930,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32u(v *ssa.Value) bool {
+func rewriteValue_OpHmul32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1952,7 +1952,7 @@
return true
}
}
-func rewriteValueS390X_OpITab(v *ssa.Value) bool {
+func rewriteValue_OpITab(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ITab (Load ptr mem))
// result: (MOVDload ptr mem)
@@ -1968,7 +1968,7 @@
}
return false
}
-func rewriteValueS390X_OpIsInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1990,7 +1990,7 @@
return true
}
}
-func rewriteValueS390X_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2011,7 +2011,7 @@
return true
}
}
-func rewriteValueS390X_OpIsSliceInBounds(v *ssa.Value) bool {
+func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2033,7 +2033,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2059,7 +2059,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2085,7 +2085,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2107,7 +2107,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32F(v *ssa.Value) bool {
+func rewriteValue_OpLeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2129,7 +2129,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2151,7 +2151,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64(v *ssa.Value) bool {
+func rewriteValue_OpLeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2173,7 +2173,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64F(v *ssa.Value) bool {
+func rewriteValue_OpLeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2195,7 +2195,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64U(v *ssa.Value) bool {
+func rewriteValue_OpLeq64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2217,7 +2217,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2243,7 +2243,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2269,7 +2269,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2295,7 +2295,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2321,7 +2321,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2343,7 +2343,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32F(v *ssa.Value) bool {
+func rewriteValue_OpLess32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2365,7 +2365,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2387,7 +2387,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64(v *ssa.Value) bool {
+func rewriteValue_OpLess64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2409,7 +2409,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64F(v *ssa.Value) bool {
+func rewriteValue_OpLess64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2431,7 +2431,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64U(v *ssa.Value) bool {
+func rewriteValue_OpLess64U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2453,7 +2453,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2479,7 +2479,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2505,7 +2505,7 @@
return true
}
}
-func rewriteValueS390X_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2636,7 +2636,7 @@
}
return false
}
-func rewriteValueS390X_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2676,7 +2676,7 @@
}
return false
}
-func rewriteValueS390X_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2716,7 +2716,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2754,7 +2754,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2792,7 +2792,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2832,7 +2832,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2872,7 +2872,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2910,7 +2910,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2948,7 +2948,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2988,7 +2988,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3028,7 +3028,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3066,7 +3066,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3104,7 +3104,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3144,7 +3144,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3184,7 +3184,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3222,7 +3222,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3260,7 +3260,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3300,7 +3300,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3319,7 +3319,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3338,7 +3338,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3355,7 +3355,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3372,7 +3372,7 @@
return true
}
}
-func rewriteValueS390X_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -3385,7 +3385,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3404,7 +3404,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3423,7 +3423,7 @@
return true
}
}
-func rewriteValueS390X_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3741,7 +3741,7 @@
}
return false
}
-func rewriteValueS390X_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3767,7 +3767,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3789,7 +3789,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32F(v *ssa.Value) bool {
+func rewriteValue_OpNeq32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3811,7 +3811,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64(v *ssa.Value) bool {
+func rewriteValue_OpNeq64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3833,7 +3833,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64F(v *ssa.Value) bool {
+func rewriteValue_OpNeq64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3855,7 +3855,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3881,7 +3881,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqB(v *ssa.Value) bool {
+func rewriteValue_OpNeqB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3907,7 +3907,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqPtr(v *ssa.Value) bool {
+func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3929,7 +3929,7 @@
return true
}
}
-func rewriteValueS390X_OpNot(v *ssa.Value) bool {
+func rewriteValue_OpNot(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORWconst [1] x)
@@ -3941,7 +3941,7 @@
return true
}
}
-func rewriteValueS390X_OpOffPtr(v *ssa.Value) bool {
+func rewriteValue_OpOffPtr(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3984,7 +3984,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4001,7 +4001,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4018,7 +4018,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount64(v *ssa.Value) bool {
+func rewriteValue_OpPopCount64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4035,7 +4035,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4050,7 +4050,7 @@
return true
}
}
-func rewriteValueS390X_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4078,7 +4078,7 @@
}
return false
}
-func rewriteValueS390X_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4106,7 +4106,7 @@
}
return false
}
-func rewriteValueS390X_OpRound(v *ssa.Value) bool {
+func rewriteValue_OpRound(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Round x)
// result: (FIDBR [1] x)
@@ -4118,7 +4118,7 @@
return true
}
}
-func rewriteValueS390X_OpRoundToEven(v *ssa.Value) bool {
+func rewriteValue_OpRoundToEven(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (FIDBR [4] x)
@@ -4130,7 +4130,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4174,7 +4174,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4216,7 +4216,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4258,7 +4258,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4302,7 +4302,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4344,7 +4344,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4384,7 +4384,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4424,7 +4424,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4466,7 +4466,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4506,7 +4506,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4544,7 +4544,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4582,7 +4582,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4622,7 +4622,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4660,7 +4660,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4695,7 +4695,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4730,7 +4730,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4768,7 +4768,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4808,7 +4808,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4846,7 +4846,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4884,7 +4884,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4924,7 +4924,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4962,7 +4962,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4997,7 +4997,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5032,7 +5032,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5070,7 +5070,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5114,7 +5114,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5156,7 +5156,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5198,7 +5198,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5242,7 +5242,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5284,7 +5284,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5324,7 +5324,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5364,7 +5364,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5406,7 +5406,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XADD(v *ssa.Value) bool {
+func rewriteValue_OpS390XADD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD x (MOVDconst <t> [c]))
@@ -5497,7 +5497,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDC(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDC x (MOVDconst [c]))
@@ -5522,7 +5522,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDE(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5585,7 +5585,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDW(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDW x (MOVDconst [c]))
@@ -5675,7 +5675,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDWconst [c] x)
// cond: int32(c)==0
@@ -5717,7 +5717,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5768,7 +5768,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
// cond: ((c+d)&1 == 0) && ssa.Is32Bit(int64(c)+int64(d))
@@ -5873,7 +5873,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDload(v *ssa.Value) bool {
+func rewriteValue_OpS390XADDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5948,7 +5948,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XAND(v *ssa.Value) bool {
+func rewriteValue_OpS390XAND(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6072,7 +6072,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDW(v *ssa.Value) bool {
+func rewriteValue_OpS390XANDW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDW x (MOVDconst [c]))
@@ -6157,7 +6157,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XANDWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDWconst [c] (ANDWconst [d] x))
// result: (ANDWconst [c&d] x)
@@ -6233,7 +6233,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XANDWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6284,7 +6284,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XANDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [c] (ANDconst [d] x))
// result: (ANDconst [c&d] x)
@@ -6334,7 +6334,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDload(v *ssa.Value) bool {
+func rewriteValue_OpS390XANDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6409,7 +6409,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMP(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6466,7 +6466,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPU(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6523,7 +6523,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPUconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: uint64(x)==uint64(y)
@@ -6709,7 +6709,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPW(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6806,7 +6806,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWU(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPWU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6903,7 +6903,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWUconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPWUconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: uint32(x)==uint32(y)
@@ -7030,7 +7030,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -7175,7 +7175,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XCMPconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==int64(y)
@@ -7379,7 +7379,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCPSDR(v *ssa.Value) bool {
+func rewriteValue_OpS390XCPSDR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CPSDR y (FMOVDconst [c]))
@@ -7416,7 +7416,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFCMP(v *ssa.Value) bool {
+func rewriteValue_OpS390XFCMP(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7446,7 +7446,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFCMPS(v *ssa.Value) bool {
+func rewriteValue_OpS390XFCMPS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7476,7 +7476,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpS390XFMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
@@ -7561,7 +7561,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XFMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7612,7 +7612,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSload(v *ssa.Value) bool {
+func rewriteValue_OpS390XFMOVSload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVSload [off] {sym} ptr1 (FMOVSstore [off] {sym} ptr2 x _))
@@ -7678,7 +7678,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XFMOVSstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7729,7 +7729,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFNEG(v *ssa.Value) bool {
+func rewriteValue_OpS390XFNEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FNEG (LPDFR x))
// result: (LNDFR x)
@@ -7755,7 +7755,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFNEGS(v *ssa.Value) bool {
+func rewriteValue_OpS390XFNEGS(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (FNEGS (LPDFR x))
// result: (LNDFR x)
@@ -7781,7 +7781,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLDGR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLDGR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LDGR <t> (RISBGZ x {r}))
@@ -7871,7 +7871,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLEDBR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLEDBR(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LEDBR (LPDFR (LDEBR x)))
// result: (LPDFR x)
@@ -7905,7 +7905,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLGDR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLGDR(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LGDR (LDGR x))
// result: x
@@ -7919,7 +7919,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLOCGR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLOCGR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8036,7 +8036,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLTDBR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLTDBR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LTDBR (Select0 x:(FADD _ _)))
@@ -8071,7 +8071,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLTEBR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLTEBR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LTEBR (Select0 x:(FADDS _ _)))
@@ -8106,7 +8106,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredPanicBoundsCR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLoweredPanicBoundsCR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsCR [kind] {p} (MOVDconst [c]) mem)
@@ -8127,7 +8127,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredPanicBoundsRC(v *ssa.Value) bool {
+func rewriteValue_OpS390XLoweredPanicBoundsRC(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LoweredPanicBoundsRC [kind] {p} (MOVDconst [c]) mem)
@@ -8148,7 +8148,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredPanicBoundsRR(v *ssa.Value) bool {
+func rewriteValue_OpS390XLoweredPanicBoundsRR(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8186,7 +8186,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound32F(v *ssa.Value) bool {
+func rewriteValue_OpS390XLoweredRound32F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LoweredRound32F x:(FMOVSconst))
// result: x
@@ -8200,7 +8200,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound64F(v *ssa.Value) bool {
+func rewriteValue_OpS390XLoweredRound64F(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (LoweredRound64F x:(FMOVDconst))
// result: x
@@ -8214,7 +8214,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBZload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
@@ -8281,7 +8281,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8501,7 +8501,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
@@ -8568,7 +8568,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8750,7 +8750,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8856,7 +8856,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVBstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -8904,7 +8904,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDBR(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDBR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8957,7 +8957,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDaddridx(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDaddridx(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
@@ -9048,7 +9048,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
@@ -9134,7 +9134,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9310,7 +9310,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -9358,7 +9358,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVDstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9388,7 +9388,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHZload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
@@ -9456,7 +9456,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9646,7 +9646,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
@@ -9714,7 +9714,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9902,7 +9902,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10026,7 +10026,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -10074,7 +10074,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVHstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10099,7 +10099,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBR(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWBR(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10156,7 +10156,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWZload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWZload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
@@ -10224,7 +10224,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWZreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWZreg e:(MOVBZreg x))
@@ -10393,7 +10393,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWload(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
@@ -10461,7 +10461,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWreg(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWreg(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWreg e:(MOVBreg x))
@@ -10635,7 +10635,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstore(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWstore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10845,7 +10845,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWstoreconst(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -10893,7 +10893,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreidx(v *ssa.Value) bool {
+func rewriteValue_OpS390XMOVWstoreidx(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10923,7 +10923,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLD(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLD x (MOVDconst [c]))
@@ -10975,7 +10975,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLDconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLDconst <t> x [c])
@@ -11052,7 +11052,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLDload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLDload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11127,7 +11127,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLW(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLW x (MOVDconst [c]))
@@ -11202,7 +11202,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLWconst <t> x [c])
@@ -11279,7 +11279,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XMULLWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11330,7 +11330,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEG(v *ssa.Value) bool {
+func rewriteValue_OpS390XNEG(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEG (MOVDconst [c]))
// result: (MOVDconst [-c])
@@ -11376,7 +11376,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEGW(v *ssa.Value) bool {
+func rewriteValue_OpS390XNEGW(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NEGW (MOVDconst [c]))
// result: (MOVDconst [int64(int32(-c))])
@@ -11391,7 +11391,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNOT(v *ssa.Value) bool {
+func rewriteValue_OpS390XNOT(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11406,7 +11406,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XNOTW(v *ssa.Value) bool {
+func rewriteValue_OpS390XNOTW(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (NOTW x)
// result: (XORWconst [-1] x)
@@ -11418,7 +11418,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XOR(v *ssa.Value) bool {
+func rewriteValue_OpS390XOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11582,7 +11582,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORW(v *ssa.Value) bool {
+func rewriteValue_OpS390XORW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORW x (MOVDconst [c]))
@@ -11667,7 +11667,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XORWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORWconst [c] x)
// cond: int32(c)==0
@@ -11707,7 +11707,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XORWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11758,7 +11758,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -11794,7 +11794,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORload(v *ssa.Value) bool {
+func rewriteValue_OpS390XORload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11869,7 +11869,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XRISBGZ(v *ssa.Value) bool {
+func rewriteValue_OpS390XRISBGZ(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (RISBGZ (MOVWZreg x) {r})
@@ -12084,7 +12084,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XRLL(v *ssa.Value) bool {
+func rewriteValue_OpS390XRLL(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RLL x (MOVDconst [c]))
@@ -12102,7 +12102,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XRLLG(v *ssa.Value) bool {
+func rewriteValue_OpS390XRLLG(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RLLG x (MOVDconst [c]))
@@ -12120,7 +12120,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLD(v *ssa.Value) bool {
+func rewriteValue_OpS390XSLD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12271,7 +12271,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLDconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSLDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLDconst (SRDconst x [c]) [d])
// result: (RISBGZ x {s390x.NewRotateParams(uint8(max(0, int8(c-d))), 63-d, uint8(int8(d-c)&63))})
@@ -12317,7 +12317,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLW(v *ssa.Value) bool {
+func rewriteValue_OpS390XSLW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12487,7 +12487,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSLWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SLWconst x [0])
// result: x
@@ -12501,7 +12501,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAD(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRAD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12652,7 +12652,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRADconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRADconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRADconst x [0])
// result: x
@@ -12678,7 +12678,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAW(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRAW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12850,7 +12850,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRAWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRAWconst x [0])
// result: x
@@ -12876,7 +12876,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRD(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRD(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13027,7 +13027,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRDconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRDconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRDconst (SLDconst x [c]) [d])
// result: (RISBGZ x {s390x.NewRotateParams(d, uint8(min(63, int8(63-c+d))), uint8(int8(c-d)&63))})
@@ -13073,7 +13073,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRW(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13243,7 +13243,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSRWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SRWconst x [0])
// result: x
@@ -13257,7 +13257,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTM2(v *ssa.Value) bool {
+func rewriteValue_OpS390XSTM2(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13312,7 +13312,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTMG2(v *ssa.Value) bool {
+func rewriteValue_OpS390XSTMG2(v *ssa.Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13347,7 +13347,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUB(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUB(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13436,7 +13436,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBE(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBE(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13508,7 +13508,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBW(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13613,7 +13613,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBWconst [c] x)
// cond: int32(c) == 0
@@ -13638,7 +13638,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSUBWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13689,7 +13689,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -13747,7 +13747,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBload(v *ssa.Value) bool {
+func rewriteValue_OpS390XSUBload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13822,7 +13822,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSumBytes2(v *ssa.Value) bool {
+func rewriteValue_OpS390XSumBytes2(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13838,7 +13838,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSumBytes4(v *ssa.Value) bool {
+func rewriteValue_OpS390XSumBytes4(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13856,7 +13856,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSumBytes8(v *ssa.Value) bool {
+func rewriteValue_OpS390XSumBytes8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13874,7 +13874,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XXOR(v *ssa.Value) bool {
+func rewriteValue_OpS390XXOR(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVDconst [c]))
@@ -13955,7 +13955,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORW(v *ssa.Value) bool {
+func rewriteValue_OpS390XXORW(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORW x (MOVDconst [c]))
@@ -14041,7 +14041,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORWconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XXORWconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORWconst [c] x)
// cond: int32(c)==0
@@ -14069,7 +14069,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORWload(v *ssa.Value) bool {
+func rewriteValue_OpS390XXORWload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14120,7 +14120,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORconst(v *ssa.Value) bool {
+func rewriteValue_OpS390XXORconst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -14146,7 +14146,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORload(v *ssa.Value) bool {
+func rewriteValue_OpS390XXORload(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14221,7 +14221,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14431,7 +14431,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14599,7 +14599,7 @@
}
return false
}
-func rewriteValueS390X_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -14615,7 +14615,7 @@
return true
}
}
-func rewriteValueS390X_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14711,7 +14711,7 @@
}
return false
}
-func rewriteValueS390X_OpSub32F(v *ssa.Value) bool {
+func rewriteValue_OpSub32F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14728,7 +14728,7 @@
return true
}
}
-func rewriteValueS390X_OpSub64F(v *ssa.Value) bool {
+func rewriteValue_OpSub64F(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14745,7 +14745,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc(v *ssa.Value) bool {
+func rewriteValue_OpTrunc(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (FIDBR [5] x)
@@ -14757,7 +14757,7 @@
return true
}
}
-func rewriteValueS390X_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14922,7 +14922,7 @@
}
return false
}
-func rewriteBlockS390X(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
typ := &b.Func.Config.Types
switch b.Kind {
case block.BlockS390XBRC:
diff --git a/src/cmd/compile/internal/ssacompile/s390x_helpers.go b/src/cmd/compile/internal/ssarewrite/rewrites390x/s390x_helpers.go
similarity index 96%
rename from src/cmd/compile/internal/ssacompile/s390x_helpers.go
rename to src/cmd/compile/internal/ssarewrite/rewrites390x/s390x_helpers.go
index 7b0e157..c8aff51 100644
--- a/src/cmd/compile/internal/ssacompile/s390x_helpers.go
+++ b/src/cmd/compile/internal/ssarewrite/rewrites390x/s390x_helpers.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package ssacompile
+package rewrites390x
// is8Bit reports whether n can be represented as a signed 8 bit integer.
func is8Bit(n int64) bool {
diff --git a/src/cmd/compile/internal/ssacompile/rewriteWasm.go b/src/cmd/compile/internal/ssarewrite/rewritewasm/rewriteWasm.go
similarity index 89%
rename from src/cmd/compile/internal/ssacompile/rewriteWasm.go
rename to src/cmd/compile/internal/ssarewrite/rewritewasm/rewriteWasm.go
index 9806ec2..ddc69c3 100644
--- a/src/cmd/compile/internal/ssacompile/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssarewrite/rewritewasm/rewriteWasm.go
@@ -1,13 +1,13 @@
// Code generated from _gen/Wasm.rules using 'go generate'; DO NOT EDIT.
-package ssacompile
+package rewritewasm
import "math"
import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"
-func rewriteValueWasm(v *ssa.Value) bool {
+func RewriteValue(v *ssa.Value) bool {
switch v.Op {
case ssaop.OpAbs:
v.Op = ssaop.OpWasmF64Abs
@@ -82,7 +82,7 @@
v.Op = ssaop.OpWasmI8x16AddSatU
return true
case ssaop.OpAddr:
- return rewriteValueWasm_OpAddr(v)
+ return rewriteValue_OpAddr(v)
case ssaop.OpAnd16:
v.Op = ssaop.OpWasmI64And
return true
@@ -153,15 +153,15 @@
v.Op = ssaop.OpWasmI8x16AvgrU
return true
case ssaop.OpAvg64u:
- return rewriteValueWasm_OpAvg64u(v)
+ return rewriteValue_OpAvg64u(v)
case ssaop.OpBitLen16:
- return rewriteValueWasm_OpBitLen16(v)
+ return rewriteValue_OpBitLen16(v)
case ssaop.OpBitLen32:
- return rewriteValueWasm_OpBitLen32(v)
+ return rewriteValue_OpBitLen32(v)
case ssaop.OpBitLen64:
- return rewriteValueWasm_OpBitLen64(v)
+ return rewriteValue_OpBitLen64(v)
case ssaop.OpBitLen8:
- return rewriteValueWasm_OpBitLen8(v)
+ return rewriteValue_OpBitLen8(v)
case ssaop.OpBitSelectInt16x8:
v.Op = ssaop.OpWasmV128Bitselect
return true
@@ -217,20 +217,20 @@
v.Op = ssaop.OpWasmLoweredClosureCall
return true
case ssaop.OpCom16:
- return rewriteValueWasm_OpCom16(v)
+ return rewriteValue_OpCom16(v)
case ssaop.OpCom32:
- return rewriteValueWasm_OpCom32(v)
+ return rewriteValue_OpCom32(v)
case ssaop.OpCom64:
- return rewriteValueWasm_OpCom64(v)
+ return rewriteValue_OpCom64(v)
case ssaop.OpCom8:
- return rewriteValueWasm_OpCom8(v)
+ return rewriteValue_OpCom8(v)
case ssaop.OpCondSelect:
v.Op = ssaop.OpWasmSelect
return true
case ssaop.OpConst16:
- return rewriteValueWasm_OpConst16(v)
+ return rewriteValue_OpConst16(v)
case ssaop.OpConst32:
- return rewriteValueWasm_OpConst32(v)
+ return rewriteValue_OpConst32(v)
case ssaop.OpConst32F:
v.Op = ssaop.OpWasmF32Const
return true
@@ -241,11 +241,11 @@
v.Op = ssaop.OpWasmF64Const
return true
case ssaop.OpConst8:
- return rewriteValueWasm_OpConst8(v)
+ return rewriteValue_OpConst8(v)
case ssaop.OpConstBool:
- return rewriteValueWasm_OpConstBool(v)
+ return rewriteValue_OpConstBool(v)
case ssaop.OpConstNil:
- return rewriteValueWasm_OpConstNil(v)
+ return rewriteValue_OpConstNil(v)
case ssaop.OpConvert:
v.Op = ssaop.OpWasmLoweredConvert
return true
@@ -271,12 +271,12 @@
v.Op = ssaop.OpWasmF64Copysign
return true
case ssaop.OpCtz16:
- return rewriteValueWasm_OpCtz16(v)
+ return rewriteValue_OpCtz16(v)
case ssaop.OpCtz16NonZero:
v.Op = ssaop.OpWasmI64Ctz
return true
case ssaop.OpCtz32:
- return rewriteValueWasm_OpCtz32(v)
+ return rewriteValue_OpCtz32(v)
case ssaop.OpCtz32NonZero:
v.Op = ssaop.OpWasmI64Ctz
return true
@@ -287,7 +287,7 @@
v.Op = ssaop.OpWasmI64Ctz
return true
case ssaop.OpCtz8:
- return rewriteValueWasm_OpCtz8(v)
+ return rewriteValue_OpCtz8(v)
case ssaop.OpCtz8NonZero:
v.Op = ssaop.OpWasmI64Ctz
return true
@@ -307,13 +307,13 @@
v.Op = ssaop.OpWasmI64TruncSatF32U
return true
case ssaop.OpCvt32Uto32F:
- return rewriteValueWasm_OpCvt32Uto32F(v)
+ return rewriteValue_OpCvt32Uto32F(v)
case ssaop.OpCvt32Uto64F:
- return rewriteValueWasm_OpCvt32Uto64F(v)
+ return rewriteValue_OpCvt32Uto64F(v)
case ssaop.OpCvt32to32F:
- return rewriteValueWasm_OpCvt32to32F(v)
+ return rewriteValue_OpCvt32to32F(v)
case ssaop.OpCvt32to64F:
- return rewriteValueWasm_OpCvt32to64F(v)
+ return rewriteValue_OpCvt32to64F(v)
case ssaop.OpCvt64Fto32:
v.Op = ssaop.OpWasmI64TruncSatF64S
return true
@@ -345,18 +345,18 @@
v.Op = ssaop.OpCopy
return true
case ssaop.OpDiv16:
- return rewriteValueWasm_OpDiv16(v)
+ return rewriteValue_OpDiv16(v)
case ssaop.OpDiv16u:
- return rewriteValueWasm_OpDiv16u(v)
+ return rewriteValue_OpDiv16u(v)
case ssaop.OpDiv32:
- return rewriteValueWasm_OpDiv32(v)
+ return rewriteValue_OpDiv32(v)
case ssaop.OpDiv32F:
v.Op = ssaop.OpWasmF32Div
return true
case ssaop.OpDiv32u:
- return rewriteValueWasm_OpDiv32u(v)
+ return rewriteValue_OpDiv32u(v)
case ssaop.OpDiv64:
- return rewriteValueWasm_OpDiv64(v)
+ return rewriteValue_OpDiv64(v)
case ssaop.OpDiv64F:
v.Op = ssaop.OpWasmF64Div
return true
@@ -364,9 +364,9 @@
v.Op = ssaop.OpWasmI64DivU
return true
case ssaop.OpDiv8:
- return rewriteValueWasm_OpDiv8(v)
+ return rewriteValue_OpDiv8(v)
case ssaop.OpDiv8u:
- return rewriteValueWasm_OpDiv8u(v)
+ return rewriteValue_OpDiv8u(v)
case ssaop.OpDivFloat32x4:
v.Op = ssaop.OpWasmF32x4Div
return true
@@ -374,9 +374,9 @@
v.Op = ssaop.OpWasmF64x2Div
return true
case ssaop.OpEq16:
- return rewriteValueWasm_OpEq16(v)
+ return rewriteValue_OpEq16(v)
case ssaop.OpEq32:
- return rewriteValueWasm_OpEq32(v)
+ return rewriteValue_OpEq32(v)
case ssaop.OpEq32F:
v.Op = ssaop.OpWasmF32Eq
return true
@@ -387,7 +387,7 @@
v.Op = ssaop.OpWasmF64Eq
return true
case ssaop.OpEq8:
- return rewriteValueWasm_OpEq8(v)
+ return rewriteValue_OpEq8(v)
case ssaop.OpEqB:
v.Op = ssaop.OpWasmI64Eq
return true
@@ -563,9 +563,9 @@
v.Op = ssaop.OpWasmI8x16GtU
return true
case ssaop.OpHmul64:
- return rewriteValueWasm_OpHmul64(v)
+ return rewriteValue_OpHmul64(v)
case ssaop.OpHmul64u:
- return rewriteValueWasm_OpHmul64u(v)
+ return rewriteValue_OpHmul64u(v)
case ssaop.OpInterCall:
v.Op = ssaop.OpWasmLoweredInterCall
return true
@@ -573,23 +573,23 @@
v.Op = ssaop.OpWasmI64LtU
return true
case ssaop.OpIsNonNil:
- return rewriteValueWasm_OpIsNonNil(v)
+ return rewriteValue_OpIsNonNil(v)
case ssaop.OpIsSliceInBounds:
v.Op = ssaop.OpWasmI64LeU
return true
case ssaop.OpLast:
- return rewriteValueWasm_OpLast(v)
+ return rewriteValue_OpLast(v)
case ssaop.OpLeq16:
- return rewriteValueWasm_OpLeq16(v)
+ return rewriteValue_OpLeq16(v)
case ssaop.OpLeq16U:
- return rewriteValueWasm_OpLeq16U(v)
+ return rewriteValue_OpLeq16U(v)
case ssaop.OpLeq32:
- return rewriteValueWasm_OpLeq32(v)
+ return rewriteValue_OpLeq32(v)
case ssaop.OpLeq32F:
v.Op = ssaop.OpWasmF32Le
return true
case ssaop.OpLeq32U:
- return rewriteValueWasm_OpLeq32U(v)
+ return rewriteValue_OpLeq32U(v)
case ssaop.OpLeq64:
v.Op = ssaop.OpWasmI64LeS
return true
@@ -600,20 +600,20 @@
v.Op = ssaop.OpWasmI64LeU
return true
case ssaop.OpLeq8:
- return rewriteValueWasm_OpLeq8(v)
+ return rewriteValue_OpLeq8(v)
case ssaop.OpLeq8U:
- return rewriteValueWasm_OpLeq8U(v)
+ return rewriteValue_OpLeq8U(v)
case ssaop.OpLess16:
- return rewriteValueWasm_OpLess16(v)
+ return rewriteValue_OpLess16(v)
case ssaop.OpLess16U:
- return rewriteValueWasm_OpLess16U(v)
+ return rewriteValue_OpLess16U(v)
case ssaop.OpLess32:
- return rewriteValueWasm_OpLess32(v)
+ return rewriteValue_OpLess32(v)
case ssaop.OpLess32F:
v.Op = ssaop.OpWasmF32Lt
return true
case ssaop.OpLess32U:
- return rewriteValueWasm_OpLess32U(v)
+ return rewriteValue_OpLess32U(v)
case ssaop.OpLess64:
v.Op = ssaop.OpWasmI64LtS
return true
@@ -624,9 +624,9 @@
v.Op = ssaop.OpWasmI64LtU
return true
case ssaop.OpLess8:
- return rewriteValueWasm_OpLess8(v)
+ return rewriteValue_OpLess8(v)
case ssaop.OpLess8U:
- return rewriteValueWasm_OpLess8U(v)
+ return rewriteValue_OpLess8U(v)
case ssaop.OpLessEqualFloat32x4:
v.Op = ssaop.OpWasmF32x4Le
return true
@@ -682,47 +682,47 @@
v.Op = ssaop.OpWasmI8x16LtU
return true
case ssaop.OpLoad:
- return rewriteValueWasm_OpLoad(v)
+ return rewriteValue_OpLoad(v)
case ssaop.OpLocalAddr:
- return rewriteValueWasm_OpLocalAddr(v)
+ return rewriteValue_OpLocalAddr(v)
case ssaop.OpLookupOrZeroInt8x16:
v.Op = ssaop.OpWasmI8x16Swizzle
return true
case ssaop.OpLsh16x16:
- return rewriteValueWasm_OpLsh16x16(v)
+ return rewriteValue_OpLsh16x16(v)
case ssaop.OpLsh16x32:
- return rewriteValueWasm_OpLsh16x32(v)
+ return rewriteValue_OpLsh16x32(v)
case ssaop.OpLsh16x64:
v.Op = ssaop.OpLsh64x64
return true
case ssaop.OpLsh16x8:
- return rewriteValueWasm_OpLsh16x8(v)
+ return rewriteValue_OpLsh16x8(v)
case ssaop.OpLsh32x16:
- return rewriteValueWasm_OpLsh32x16(v)
+ return rewriteValue_OpLsh32x16(v)
case ssaop.OpLsh32x32:
- return rewriteValueWasm_OpLsh32x32(v)
+ return rewriteValue_OpLsh32x32(v)
case ssaop.OpLsh32x64:
v.Op = ssaop.OpLsh64x64
return true
case ssaop.OpLsh32x8:
- return rewriteValueWasm_OpLsh32x8(v)
+ return rewriteValue_OpLsh32x8(v)
case ssaop.OpLsh64x16:
- return rewriteValueWasm_OpLsh64x16(v)
+ return rewriteValue_OpLsh64x16(v)
case ssaop.OpLsh64x32:
- return rewriteValueWasm_OpLsh64x32(v)
+ return rewriteValue_OpLsh64x32(v)
case ssaop.OpLsh64x64:
- return rewriteValueWasm_OpLsh64x64(v)
+ return rewriteValue_OpLsh64x64(v)
case ssaop.OpLsh64x8:
- return rewriteValueWasm_OpLsh64x8(v)
+ return rewriteValue_OpLsh64x8(v)
case ssaop.OpLsh8x16:
- return rewriteValueWasm_OpLsh8x16(v)
+ return rewriteValue_OpLsh8x16(v)
case ssaop.OpLsh8x32:
- return rewriteValueWasm_OpLsh8x32(v)
+ return rewriteValue_OpLsh8x32(v)
case ssaop.OpLsh8x64:
v.Op = ssaop.OpLsh64x64
return true
case ssaop.OpLsh8x8:
- return rewriteValueWasm_OpLsh8x8(v)
+ return rewriteValue_OpLsh8x8(v)
case ssaop.OpMaxFloat32x4:
v.Op = ssaop.OpWasmF32x4Max
return true
@@ -772,24 +772,24 @@
v.Op = ssaop.OpWasmI8x16MinU
return true
case ssaop.OpMod16:
- return rewriteValueWasm_OpMod16(v)
+ return rewriteValue_OpMod16(v)
case ssaop.OpMod16u:
- return rewriteValueWasm_OpMod16u(v)
+ return rewriteValue_OpMod16u(v)
case ssaop.OpMod32:
- return rewriteValueWasm_OpMod32(v)
+ return rewriteValue_OpMod32(v)
case ssaop.OpMod32u:
- return rewriteValueWasm_OpMod32u(v)
+ return rewriteValue_OpMod32u(v)
case ssaop.OpMod64:
- return rewriteValueWasm_OpMod64(v)
+ return rewriteValue_OpMod64(v)
case ssaop.OpMod64u:
v.Op = ssaop.OpWasmI64RemU
return true
case ssaop.OpMod8:
- return rewriteValueWasm_OpMod8(v)
+ return rewriteValue_OpMod8(v)
case ssaop.OpMod8u:
- return rewriteValueWasm_OpMod8u(v)
+ return rewriteValue_OpMod8u(v)
case ssaop.OpMove:
- return rewriteValueWasm_OpMove(v)
+ return rewriteValue_OpMove(v)
case ssaop.OpMul16:
v.Op = ssaop.OpWasmI64Mul
return true
@@ -869,19 +869,19 @@
v.Op = ssaop.OpWasmI16x8ExtmulLowI8x16U
return true
case ssaop.OpNeg16:
- return rewriteValueWasm_OpNeg16(v)
+ return rewriteValue_OpNeg16(v)
case ssaop.OpNeg32:
- return rewriteValueWasm_OpNeg32(v)
+ return rewriteValue_OpNeg32(v)
case ssaop.OpNeg32F:
v.Op = ssaop.OpWasmF32Neg
return true
case ssaop.OpNeg64:
- return rewriteValueWasm_OpNeg64(v)
+ return rewriteValue_OpNeg64(v)
case ssaop.OpNeg64F:
v.Op = ssaop.OpWasmF64Neg
return true
case ssaop.OpNeg8:
- return rewriteValueWasm_OpNeg8(v)
+ return rewriteValue_OpNeg8(v)
case ssaop.OpNegFloat32x4:
v.Op = ssaop.OpWasmF32x4Neg
return true
@@ -901,9 +901,9 @@
v.Op = ssaop.OpWasmI8x16Neg
return true
case ssaop.OpNeq16:
- return rewriteValueWasm_OpNeq16(v)
+ return rewriteValue_OpNeq16(v)
case ssaop.OpNeq32:
- return rewriteValueWasm_OpNeq32(v)
+ return rewriteValue_OpNeq32(v)
case ssaop.OpNeq32F:
v.Op = ssaop.OpWasmF32Ne
return true
@@ -914,7 +914,7 @@
v.Op = ssaop.OpWasmF64Ne
return true
case ssaop.OpNeq8:
- return rewriteValueWasm_OpNeq8(v)
+ return rewriteValue_OpNeq8(v)
case ssaop.OpNeqB:
v.Op = ssaop.OpWasmI64Ne
return true
@@ -1027,48 +1027,48 @@
v.Op = ssaop.OpWasmV128Or
return true
case ssaop.OpPopCount16:
- return rewriteValueWasm_OpPopCount16(v)
+ return rewriteValue_OpPopCount16(v)
case ssaop.OpPopCount32:
- return rewriteValueWasm_OpPopCount32(v)
+ return rewriteValue_OpPopCount32(v)
case ssaop.OpPopCount64:
v.Op = ssaop.OpWasmI64Popcnt
return true
case ssaop.OpPopCount8:
- return rewriteValueWasm_OpPopCount8(v)
+ return rewriteValue_OpPopCount8(v)
case ssaop.OpRotateAllLeftVarInt16x8:
- return rewriteValueWasm_OpRotateAllLeftVarInt16x8(v)
+ return rewriteValue_OpRotateAllLeftVarInt16x8(v)
case ssaop.OpRotateAllLeftVarInt32x4:
- return rewriteValueWasm_OpRotateAllLeftVarInt32x4(v)
+ return rewriteValue_OpRotateAllLeftVarInt32x4(v)
case ssaop.OpRotateAllLeftVarInt64x2:
- return rewriteValueWasm_OpRotateAllLeftVarInt64x2(v)
+ return rewriteValue_OpRotateAllLeftVarInt64x2(v)
case ssaop.OpRotateAllLeftVarInt8x16:
- return rewriteValueWasm_OpRotateAllLeftVarInt8x16(v)
+ return rewriteValue_OpRotateAllLeftVarInt8x16(v)
case ssaop.OpRotateAllLeftVarUint16x8:
- return rewriteValueWasm_OpRotateAllLeftVarUint16x8(v)
+ return rewriteValue_OpRotateAllLeftVarUint16x8(v)
case ssaop.OpRotateAllLeftVarUint32x4:
- return rewriteValueWasm_OpRotateAllLeftVarUint32x4(v)
+ return rewriteValue_OpRotateAllLeftVarUint32x4(v)
case ssaop.OpRotateAllLeftVarUint64x2:
- return rewriteValueWasm_OpRotateAllLeftVarUint64x2(v)
+ return rewriteValue_OpRotateAllLeftVarUint64x2(v)
case ssaop.OpRotateAllLeftVarUint8x16:
- return rewriteValueWasm_OpRotateAllLeftVarUint8x16(v)
+ return rewriteValue_OpRotateAllLeftVarUint8x16(v)
case ssaop.OpRotateAllRightVarInt16x8:
- return rewriteValueWasm_OpRotateAllRightVarInt16x8(v)
+ return rewriteValue_OpRotateAllRightVarInt16x8(v)
case ssaop.OpRotateAllRightVarInt32x4:
- return rewriteValueWasm_OpRotateAllRightVarInt32x4(v)
+ return rewriteValue_OpRotateAllRightVarInt32x4(v)
case ssaop.OpRotateAllRightVarInt64x2:
- return rewriteValueWasm_OpRotateAllRightVarInt64x2(v)
+ return rewriteValue_OpRotateAllRightVarInt64x2(v)
case ssaop.OpRotateAllRightVarInt8x16:
- return rewriteValueWasm_OpRotateAllRightVarInt8x16(v)
+ return rewriteValue_OpRotateAllRightVarInt8x16(v)
case ssaop.OpRotateAllRightVarUint16x8:
- return rewriteValueWasm_OpRotateAllRightVarUint16x8(v)
+ return rewriteValue_OpRotateAllRightVarUint16x8(v)
case ssaop.OpRotateAllRightVarUint32x4:
- return rewriteValueWasm_OpRotateAllRightVarUint32x4(v)
+ return rewriteValue_OpRotateAllRightVarUint32x4(v)
case ssaop.OpRotateAllRightVarUint64x2:
- return rewriteValueWasm_OpRotateAllRightVarUint64x2(v)
+ return rewriteValue_OpRotateAllRightVarUint64x2(v)
case ssaop.OpRotateAllRightVarUint8x16:
- return rewriteValueWasm_OpRotateAllRightVarUint8x16(v)
+ return rewriteValue_OpRotateAllRightVarUint8x16(v)
case ssaop.OpRotateLeft16:
- return rewriteValueWasm_OpRotateLeft16(v)
+ return rewriteValue_OpRotateLeft16(v)
case ssaop.OpRotateLeft32:
v.Op = ssaop.OpWasmI32Rotl
return true
@@ -1076,7 +1076,7 @@
v.Op = ssaop.OpWasmI64Rotl
return true
case ssaop.OpRotateLeft8:
- return rewriteValueWasm_OpRotateLeft8(v)
+ return rewriteValue_OpRotateLeft8(v)
case ssaop.OpRound32F:
v.Op = ssaop.OpCopy
return true
@@ -1093,73 +1093,73 @@
v.Op = ssaop.OpWasmF64Nearest
return true
case ssaop.OpRsh16Ux16:
- return rewriteValueWasm_OpRsh16Ux16(v)
+ return rewriteValue_OpRsh16Ux16(v)
case ssaop.OpRsh16Ux32:
- return rewriteValueWasm_OpRsh16Ux32(v)
+ return rewriteValue_OpRsh16Ux32(v)
case ssaop.OpRsh16Ux64:
- return rewriteValueWasm_OpRsh16Ux64(v)
+ return rewriteValue_OpRsh16Ux64(v)
case ssaop.OpRsh16Ux8:
- return rewriteValueWasm_OpRsh16Ux8(v)
+ return rewriteValue_OpRsh16Ux8(v)
case ssaop.OpRsh16x16:
- return rewriteValueWasm_OpRsh16x16(v)
+ return rewriteValue_OpRsh16x16(v)
case ssaop.OpRsh16x32:
- return rewriteValueWasm_OpRsh16x32(v)
+ return rewriteValue_OpRsh16x32(v)
case ssaop.OpRsh16x64:
- return rewriteValueWasm_OpRsh16x64(v)
+ return rewriteValue_OpRsh16x64(v)
case ssaop.OpRsh16x8:
- return rewriteValueWasm_OpRsh16x8(v)
+ return rewriteValue_OpRsh16x8(v)
case ssaop.OpRsh32Ux16:
- return rewriteValueWasm_OpRsh32Ux16(v)
+ return rewriteValue_OpRsh32Ux16(v)
case ssaop.OpRsh32Ux32:
- return rewriteValueWasm_OpRsh32Ux32(v)
+ return rewriteValue_OpRsh32Ux32(v)
case ssaop.OpRsh32Ux64:
- return rewriteValueWasm_OpRsh32Ux64(v)
+ return rewriteValue_OpRsh32Ux64(v)
case ssaop.OpRsh32Ux8:
- return rewriteValueWasm_OpRsh32Ux8(v)
+ return rewriteValue_OpRsh32Ux8(v)
case ssaop.OpRsh32x16:
- return rewriteValueWasm_OpRsh32x16(v)
+ return rewriteValue_OpRsh32x16(v)
case ssaop.OpRsh32x32:
- return rewriteValueWasm_OpRsh32x32(v)
+ return rewriteValue_OpRsh32x32(v)
case ssaop.OpRsh32x64:
- return rewriteValueWasm_OpRsh32x64(v)
+ return rewriteValue_OpRsh32x64(v)
case ssaop.OpRsh32x8:
- return rewriteValueWasm_OpRsh32x8(v)
+ return rewriteValue_OpRsh32x8(v)
case ssaop.OpRsh64Ux16:
- return rewriteValueWasm_OpRsh64Ux16(v)
+ return rewriteValue_OpRsh64Ux16(v)
case ssaop.OpRsh64Ux32:
- return rewriteValueWasm_OpRsh64Ux32(v)
+ return rewriteValue_OpRsh64Ux32(v)
case ssaop.OpRsh64Ux64:
- return rewriteValueWasm_OpRsh64Ux64(v)
+ return rewriteValue_OpRsh64Ux64(v)
case ssaop.OpRsh64Ux8:
- return rewriteValueWasm_OpRsh64Ux8(v)
+ return rewriteValue_OpRsh64Ux8(v)
case ssaop.OpRsh64x16:
- return rewriteValueWasm_OpRsh64x16(v)
+ return rewriteValue_OpRsh64x16(v)
case ssaop.OpRsh64x32:
- return rewriteValueWasm_OpRsh64x32(v)
+ return rewriteValue_OpRsh64x32(v)
case ssaop.OpRsh64x64:
- return rewriteValueWasm_OpRsh64x64(v)
+ return rewriteValue_OpRsh64x64(v)
case ssaop.OpRsh64x8:
- return rewriteValueWasm_OpRsh64x8(v)
+ return rewriteValue_OpRsh64x8(v)
case ssaop.OpRsh8Ux16:
- return rewriteValueWasm_OpRsh8Ux16(v)
+ return rewriteValue_OpRsh8Ux16(v)
case ssaop.OpRsh8Ux32:
- return rewriteValueWasm_OpRsh8Ux32(v)
+ return rewriteValue_OpRsh8Ux32(v)
case ssaop.OpRsh8Ux64:
- return rewriteValueWasm_OpRsh8Ux64(v)
+ return rewriteValue_OpRsh8Ux64(v)
case ssaop.OpRsh8Ux8:
- return rewriteValueWasm_OpRsh8Ux8(v)
+ return rewriteValue_OpRsh8Ux8(v)
case ssaop.OpRsh8x16:
- return rewriteValueWasm_OpRsh8x16(v)
+ return rewriteValue_OpRsh8x16(v)
case ssaop.OpRsh8x32:
- return rewriteValueWasm_OpRsh8x32(v)
+ return rewriteValue_OpRsh8x32(v)
case ssaop.OpRsh8x64:
- return rewriteValueWasm_OpRsh8x64(v)
+ return rewriteValue_OpRsh8x64(v)
case ssaop.OpRsh8x8:
- return rewriteValueWasm_OpRsh8x8(v)
+ return rewriteValue_OpRsh8x8(v)
case ssaop.OpSelect0:
- return rewriteValueWasm_OpSelect0(v)
+ return rewriteValue_OpSelect0(v)
case ssaop.OpSelect1:
- return rewriteValueWasm_OpSelect1(v)
+ return rewriteValue_OpSelect1(v)
case ssaop.OpSetElemFloat32x4:
v.Op = ssaop.OpWasmF32x4ReplaceLane
return true
@@ -1191,51 +1191,51 @@
v.Op = ssaop.OpWasmI8x16ReplaceLane
return true
case ssaop.OpShiftAllLeftInt16x8:
- return rewriteValueWasm_OpShiftAllLeftInt16x8(v)
+ return rewriteValue_OpShiftAllLeftInt16x8(v)
case ssaop.OpShiftAllLeftInt32x4:
- return rewriteValueWasm_OpShiftAllLeftInt32x4(v)
+ return rewriteValue_OpShiftAllLeftInt32x4(v)
case ssaop.OpShiftAllLeftInt64x2:
- return rewriteValueWasm_OpShiftAllLeftInt64x2(v)
+ return rewriteValue_OpShiftAllLeftInt64x2(v)
case ssaop.OpShiftAllLeftInt8x16:
- return rewriteValueWasm_OpShiftAllLeftInt8x16(v)
+ return rewriteValue_OpShiftAllLeftInt8x16(v)
case ssaop.OpShiftAllLeftUint16x8:
- return rewriteValueWasm_OpShiftAllLeftUint16x8(v)
+ return rewriteValue_OpShiftAllLeftUint16x8(v)
case ssaop.OpShiftAllLeftUint32x4:
- return rewriteValueWasm_OpShiftAllLeftUint32x4(v)
+ return rewriteValue_OpShiftAllLeftUint32x4(v)
case ssaop.OpShiftAllLeftUint64x2:
- return rewriteValueWasm_OpShiftAllLeftUint64x2(v)
+ return rewriteValue_OpShiftAllLeftUint64x2(v)
case ssaop.OpShiftAllLeftUint8x16:
- return rewriteValueWasm_OpShiftAllLeftUint8x16(v)
+ return rewriteValue_OpShiftAllLeftUint8x16(v)
case ssaop.OpShiftAllRightInt16x8:
- return rewriteValueWasm_OpShiftAllRightInt16x8(v)
+ return rewriteValue_OpShiftAllRightInt16x8(v)
case ssaop.OpShiftAllRightInt32x4:
- return rewriteValueWasm_OpShiftAllRightInt32x4(v)
+ return rewriteValue_OpShiftAllRightInt32x4(v)
case ssaop.OpShiftAllRightInt64x2:
- return rewriteValueWasm_OpShiftAllRightInt64x2(v)
+ return rewriteValue_OpShiftAllRightInt64x2(v)
case ssaop.OpShiftAllRightInt8x16:
- return rewriteValueWasm_OpShiftAllRightInt8x16(v)
+ return rewriteValue_OpShiftAllRightInt8x16(v)
case ssaop.OpShiftAllRightUint16x8:
- return rewriteValueWasm_OpShiftAllRightUint16x8(v)
+ return rewriteValue_OpShiftAllRightUint16x8(v)
case ssaop.OpShiftAllRightUint32x4:
- return rewriteValueWasm_OpShiftAllRightUint32x4(v)
+ return rewriteValue_OpShiftAllRightUint32x4(v)
case ssaop.OpShiftAllRightUint64x2:
- return rewriteValueWasm_OpShiftAllRightUint64x2(v)
+ return rewriteValue_OpShiftAllRightUint64x2(v)
case ssaop.OpShiftAllRightUint8x16:
- return rewriteValueWasm_OpShiftAllRightUint8x16(v)
+ return rewriteValue_OpShiftAllRightUint8x16(v)
case ssaop.OpSignExt16to32:
- return rewriteValueWasm_OpSignExt16to32(v)
+ return rewriteValue_OpSignExt16to32(v)
case ssaop.OpSignExt16to64:
- return rewriteValueWasm_OpSignExt16to64(v)
+ return rewriteValue_OpSignExt16to64(v)
case ssaop.OpSignExt32to64:
- return rewriteValueWasm_OpSignExt32to64(v)
+ return rewriteValue_OpSignExt32to64(v)
case ssaop.OpSignExt8to16:
- return rewriteValueWasm_OpSignExt8to16(v)
+ return rewriteValue_OpSignExt8to16(v)
case ssaop.OpSignExt8to32:
- return rewriteValueWasm_OpSignExt8to32(v)
+ return rewriteValue_OpSignExt8to32(v)
case ssaop.OpSignExt8to64:
- return rewriteValueWasm_OpSignExt8to64(v)
+ return rewriteValue_OpSignExt8to64(v)
case ssaop.OpSlicemask:
- return rewriteValueWasm_OpSlicemask(v)
+ return rewriteValue_OpSlicemask(v)
case ssaop.OpSqrt:
v.Op = ssaop.OpWasmF64Sqrt
return true
@@ -1252,7 +1252,7 @@
v.Op = ssaop.OpWasmLoweredStaticCall
return true
case ssaop.OpStore:
- return rewriteValueWasm_OpStore(v)
+ return rewriteValue_OpStore(v)
case ssaop.OpSub16:
v.Op = ssaop.OpWasmI64Sub
return true
@@ -1341,69 +1341,69 @@
v.Op = ssaop.OpWasmLoweredWB
return true
case ssaop.OpWasmF32DemoteF64:
- return rewriteValueWasm_OpWasmF32DemoteF64(v)
+ return rewriteValue_OpWasmF32DemoteF64(v)
case ssaop.OpWasmF64Add:
- return rewriteValueWasm_OpWasmF64Add(v)
+ return rewriteValue_OpWasmF64Add(v)
case ssaop.OpWasmF64Mul:
- return rewriteValueWasm_OpWasmF64Mul(v)
+ return rewriteValue_OpWasmF64Mul(v)
case ssaop.OpWasmI64Add:
- return rewriteValueWasm_OpWasmI64Add(v)
+ return rewriteValue_OpWasmI64Add(v)
case ssaop.OpWasmI64AddConst:
- return rewriteValueWasm_OpWasmI64AddConst(v)
+ return rewriteValue_OpWasmI64AddConst(v)
case ssaop.OpWasmI64And:
- return rewriteValueWasm_OpWasmI64And(v)
+ return rewriteValue_OpWasmI64And(v)
case ssaop.OpWasmI64Eq:
- return rewriteValueWasm_OpWasmI64Eq(v)
+ return rewriteValue_OpWasmI64Eq(v)
case ssaop.OpWasmI64Eqz:
- return rewriteValueWasm_OpWasmI64Eqz(v)
+ return rewriteValue_OpWasmI64Eqz(v)
case ssaop.OpWasmI64Extend16S:
- return rewriteValueWasm_OpWasmI64Extend16S(v)
+ return rewriteValue_OpWasmI64Extend16S(v)
case ssaop.OpWasmI64Extend32S:
- return rewriteValueWasm_OpWasmI64Extend32S(v)
+ return rewriteValue_OpWasmI64Extend32S(v)
case ssaop.OpWasmI64Extend8S:
- return rewriteValueWasm_OpWasmI64Extend8S(v)
+ return rewriteValue_OpWasmI64Extend8S(v)
case ssaop.OpWasmI64LeU:
- return rewriteValueWasm_OpWasmI64LeU(v)
+ return rewriteValue_OpWasmI64LeU(v)
case ssaop.OpWasmI64Load:
- return rewriteValueWasm_OpWasmI64Load(v)
+ return rewriteValue_OpWasmI64Load(v)
case ssaop.OpWasmI64Load16S:
- return rewriteValueWasm_OpWasmI64Load16S(v)
+ return rewriteValue_OpWasmI64Load16S(v)
case ssaop.OpWasmI64Load16U:
- return rewriteValueWasm_OpWasmI64Load16U(v)
+ return rewriteValue_OpWasmI64Load16U(v)
case ssaop.OpWasmI64Load32S:
- return rewriteValueWasm_OpWasmI64Load32S(v)
+ return rewriteValue_OpWasmI64Load32S(v)
case ssaop.OpWasmI64Load32U:
- return rewriteValueWasm_OpWasmI64Load32U(v)
+ return rewriteValue_OpWasmI64Load32U(v)
case ssaop.OpWasmI64Load8S:
- return rewriteValueWasm_OpWasmI64Load8S(v)
+ return rewriteValue_OpWasmI64Load8S(v)
case ssaop.OpWasmI64Load8U:
- return rewriteValueWasm_OpWasmI64Load8U(v)
+ return rewriteValue_OpWasmI64Load8U(v)
case ssaop.OpWasmI64LtU:
- return rewriteValueWasm_OpWasmI64LtU(v)
+ return rewriteValue_OpWasmI64LtU(v)
case ssaop.OpWasmI64Mul:
- return rewriteValueWasm_OpWasmI64Mul(v)
+ return rewriteValue_OpWasmI64Mul(v)
case ssaop.OpWasmI64Ne:
- return rewriteValueWasm_OpWasmI64Ne(v)
+ return rewriteValue_OpWasmI64Ne(v)
case ssaop.OpWasmI64Or:
- return rewriteValueWasm_OpWasmI64Or(v)
+ return rewriteValue_OpWasmI64Or(v)
case ssaop.OpWasmI64Shl:
- return rewriteValueWasm_OpWasmI64Shl(v)
+ return rewriteValue_OpWasmI64Shl(v)
case ssaop.OpWasmI64ShrS:
- return rewriteValueWasm_OpWasmI64ShrS(v)
+ return rewriteValue_OpWasmI64ShrS(v)
case ssaop.OpWasmI64ShrU:
- return rewriteValueWasm_OpWasmI64ShrU(v)
+ return rewriteValue_OpWasmI64ShrU(v)
case ssaop.OpWasmI64Store:
- return rewriteValueWasm_OpWasmI64Store(v)
+ return rewriteValue_OpWasmI64Store(v)
case ssaop.OpWasmI64Store16:
- return rewriteValueWasm_OpWasmI64Store16(v)
+ return rewriteValue_OpWasmI64Store16(v)
case ssaop.OpWasmI64Store32:
- return rewriteValueWasm_OpWasmI64Store32(v)
+ return rewriteValue_OpWasmI64Store32(v)
case ssaop.OpWasmI64Store8:
- return rewriteValueWasm_OpWasmI64Store8(v)
+ return rewriteValue_OpWasmI64Store8(v)
case ssaop.OpWasmI64Sub:
- return rewriteValueWasm_OpWasmI64Sub(v)
+ return rewriteValue_OpWasmI64Sub(v)
case ssaop.OpWasmI64Xor:
- return rewriteValueWasm_OpWasmI64Xor(v)
+ return rewriteValue_OpWasmI64Xor(v)
case ssaop.OpXor16:
v.Op = ssaop.OpWasmI64Xor
return true
@@ -1441,26 +1441,26 @@
v.Op = ssaop.OpWasmV128Xor
return true
case ssaop.OpZero:
- return rewriteValueWasm_OpZero(v)
+ return rewriteValue_OpZero(v)
case ssaop.OpZeroExt16to32:
- return rewriteValueWasm_OpZeroExt16to32(v)
+ return rewriteValue_OpZeroExt16to32(v)
case ssaop.OpZeroExt16to64:
- return rewriteValueWasm_OpZeroExt16to64(v)
+ return rewriteValue_OpZeroExt16to64(v)
case ssaop.OpZeroExt32to64:
- return rewriteValueWasm_OpZeroExt32to64(v)
+ return rewriteValue_OpZeroExt32to64(v)
case ssaop.OpZeroExt8to16:
- return rewriteValueWasm_OpZeroExt8to16(v)
+ return rewriteValue_OpZeroExt8to16(v)
case ssaop.OpZeroExt8to32:
- return rewriteValueWasm_OpZeroExt8to32(v)
+ return rewriteValue_OpZeroExt8to32(v)
case ssaop.OpZeroExt8to64:
- return rewriteValueWasm_OpZeroExt8to64(v)
+ return rewriteValue_OpZeroExt8to64(v)
case ssaop.OpZeroSIMD:
v.Op = ssaop.OpWasmV128Zero
return true
}
return false
}
-func rewriteValueWasm_OpAddr(v *ssa.Value) bool {
+func rewriteValue_OpAddr(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (LoweredAddr {sym} [0] base)
@@ -1474,7 +1474,7 @@
return true
}
}
-func rewriteValueWasm_OpAvg64u(v *ssa.Value) bool {
+func rewriteValue_OpAvg64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1495,7 +1495,7 @@
return true
}
}
-func rewriteValueWasm_OpBitLen16(v *ssa.Value) bool {
+func rewriteValue_OpBitLen16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1510,7 +1510,7 @@
return true
}
}
-func rewriteValueWasm_OpBitLen32(v *ssa.Value) bool {
+func rewriteValue_OpBitLen32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1525,7 +1525,7 @@
return true
}
}
-func rewriteValueWasm_OpBitLen64(v *ssa.Value) bool {
+func rewriteValue_OpBitLen64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1542,7 +1542,7 @@
return true
}
}
-func rewriteValueWasm_OpBitLen8(v *ssa.Value) bool {
+func rewriteValue_OpBitLen8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1557,7 +1557,7 @@
return true
}
}
-func rewriteValueWasm_OpCom16(v *ssa.Value) bool {
+func rewriteValue_OpCom16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1572,7 +1572,7 @@
return true
}
}
-func rewriteValueWasm_OpCom32(v *ssa.Value) bool {
+func rewriteValue_OpCom32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1587,7 +1587,7 @@
return true
}
}
-func rewriteValueWasm_OpCom64(v *ssa.Value) bool {
+func rewriteValue_OpCom64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1602,7 +1602,7 @@
return true
}
}
-func rewriteValueWasm_OpCom8(v *ssa.Value) bool {
+func rewriteValue_OpCom8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1617,7 +1617,7 @@
return true
}
}
-func rewriteValueWasm_OpConst16(v *ssa.Value) bool {
+func rewriteValue_OpConst16(v *ssa.Value) bool {
// match: (Const16 [c])
// result: (I64Const [int64(c)])
for {
@@ -1627,7 +1627,7 @@
return true
}
}
-func rewriteValueWasm_OpConst32(v *ssa.Value) bool {
+func rewriteValue_OpConst32(v *ssa.Value) bool {
// match: (Const32 [c])
// result: (I64Const [int64(c)])
for {
@@ -1637,7 +1637,7 @@
return true
}
}
-func rewriteValueWasm_OpConst8(v *ssa.Value) bool {
+func rewriteValue_OpConst8(v *ssa.Value) bool {
// match: (Const8 [c])
// result: (I64Const [int64(c)])
for {
@@ -1647,7 +1647,7 @@
return true
}
}
-func rewriteValueWasm_OpConstBool(v *ssa.Value) bool {
+func rewriteValue_OpConstBool(v *ssa.Value) bool {
// match: (ConstBool [c])
// result: (I64Const [ssa.B2i(c)])
for {
@@ -1657,7 +1657,7 @@
return true
}
}
-func rewriteValueWasm_OpConstNil(v *ssa.Value) bool {
+func rewriteValue_OpConstNil(v *ssa.Value) bool {
// match: (ConstNil)
// result: (I64Const [0])
for {
@@ -1666,7 +1666,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz16(v *ssa.Value) bool {
+func rewriteValue_OpCtz16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1683,7 +1683,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz32(v *ssa.Value) bool {
+func rewriteValue_OpCtz32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1700,7 +1700,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz8(v *ssa.Value) bool {
+func rewriteValue_OpCtz8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1717,7 +1717,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Uto32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Uto32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1732,7 +1732,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Uto64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32Uto64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1747,7 +1747,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32to32F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to32F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1762,7 +1762,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32to64F(v *ssa.Value) bool {
+func rewriteValue_OpCvt32to64F(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1777,7 +1777,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv16(v *ssa.Value) bool {
+func rewriteValue_OpDiv16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1800,7 +1800,7 @@
}
return false
}
-func rewriteValueWasm_OpDiv16u(v *ssa.Value) bool {
+func rewriteValue_OpDiv16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1819,7 +1819,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv32(v *ssa.Value) bool {
+func rewriteValue_OpDiv32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1842,7 +1842,7 @@
}
return false
}
-func rewriteValueWasm_OpDiv32u(v *ssa.Value) bool {
+func rewriteValue_OpDiv32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1861,7 +1861,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv64(v *ssa.Value) bool {
+func rewriteValue_OpDiv64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 [false] x y)
@@ -1878,7 +1878,7 @@
}
return false
}
-func rewriteValueWasm_OpDiv8(v *ssa.Value) bool {
+func rewriteValue_OpDiv8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1897,7 +1897,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv8u(v *ssa.Value) bool {
+func rewriteValue_OpDiv8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1916,7 +1916,7 @@
return true
}
}
-func rewriteValueWasm_OpEq16(v *ssa.Value) bool {
+func rewriteValue_OpEq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1935,7 +1935,7 @@
return true
}
}
-func rewriteValueWasm_OpEq32(v *ssa.Value) bool {
+func rewriteValue_OpEq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1954,7 +1954,7 @@
return true
}
}
-func rewriteValueWasm_OpEq8(v *ssa.Value) bool {
+func rewriteValue_OpEq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1973,7 +1973,7 @@
return true
}
}
-func rewriteValueWasm_OpHmul64(v *ssa.Value) bool {
+func rewriteValue_OpHmul64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2024,7 +2024,7 @@
return true
}
}
-func rewriteValueWasm_OpHmul64u(v *ssa.Value) bool {
+func rewriteValue_OpHmul64u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2075,7 +2075,7 @@
return true
}
}
-func rewriteValueWasm_OpIsNonNil(v *ssa.Value) bool {
+func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2090,7 +2090,7 @@
return true
}
}
-func rewriteValueWasm_OpLast(v *ssa.Value) bool {
+func rewriteValue_OpLast(v *ssa.Value) bool {
// match: (Last ___)
// result: v.Args[len(v.Args)-1]
for {
@@ -2098,7 +2098,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq16(v *ssa.Value) bool {
+func rewriteValue_OpLeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2117,7 +2117,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq16U(v *ssa.Value) bool {
+func rewriteValue_OpLeq16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2136,7 +2136,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq32(v *ssa.Value) bool {
+func rewriteValue_OpLeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2155,7 +2155,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq32U(v *ssa.Value) bool {
+func rewriteValue_OpLeq32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2174,7 +2174,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq8(v *ssa.Value) bool {
+func rewriteValue_OpLeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2193,7 +2193,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq8U(v *ssa.Value) bool {
+func rewriteValue_OpLeq8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2212,7 +2212,7 @@
return true
}
}
-func rewriteValueWasm_OpLess16(v *ssa.Value) bool {
+func rewriteValue_OpLess16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2231,7 +2231,7 @@
return true
}
}
-func rewriteValueWasm_OpLess16U(v *ssa.Value) bool {
+func rewriteValue_OpLess16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2250,7 +2250,7 @@
return true
}
}
-func rewriteValueWasm_OpLess32(v *ssa.Value) bool {
+func rewriteValue_OpLess32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2269,7 +2269,7 @@
return true
}
}
-func rewriteValueWasm_OpLess32U(v *ssa.Value) bool {
+func rewriteValue_OpLess32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2288,7 +2288,7 @@
return true
}
}
-func rewriteValueWasm_OpLess8(v *ssa.Value) bool {
+func rewriteValue_OpLess8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2307,7 +2307,7 @@
return true
}
}
-func rewriteValueWasm_OpLess8U(v *ssa.Value) bool {
+func rewriteValue_OpLess8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2326,7 +2326,7 @@
return true
}
}
-func rewriteValueWasm_OpLoad(v *ssa.Value) bool {
+func rewriteValue_OpLoad(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2471,7 +2471,7 @@
}
return false
}
-func rewriteValueWasm_OpLocalAddr(v *ssa.Value) bool {
+func rewriteValue_OpLocalAddr(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2511,7 +2511,7 @@
}
return false
}
-func rewriteValueWasm_OpLsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2530,7 +2530,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2549,7 +2549,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2568,7 +2568,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2587,7 +2587,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2606,7 +2606,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2625,7 +2625,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2644,7 +2644,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2663,7 +2663,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2732,7 +2732,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2751,7 +2751,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2770,7 +2770,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2789,7 +2789,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2808,7 +2808,7 @@
return true
}
}
-func rewriteValueWasm_OpMod16(v *ssa.Value) bool {
+func rewriteValue_OpMod16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2831,7 +2831,7 @@
}
return false
}
-func rewriteValueWasm_OpMod16u(v *ssa.Value) bool {
+func rewriteValue_OpMod16u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2850,7 +2850,7 @@
return true
}
}
-func rewriteValueWasm_OpMod32(v *ssa.Value) bool {
+func rewriteValue_OpMod32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2873,7 +2873,7 @@
}
return false
}
-func rewriteValueWasm_OpMod32u(v *ssa.Value) bool {
+func rewriteValue_OpMod32u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2892,7 +2892,7 @@
return true
}
}
-func rewriteValueWasm_OpMod64(v *ssa.Value) bool {
+func rewriteValue_OpMod64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 [false] x y)
@@ -2909,7 +2909,7 @@
}
return false
}
-func rewriteValueWasm_OpMod8(v *ssa.Value) bool {
+func rewriteValue_OpMod8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2928,7 +2928,7 @@
return true
}
}
-func rewriteValueWasm_OpMod8u(v *ssa.Value) bool {
+func rewriteValue_OpMod8u(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2947,7 +2947,7 @@
return true
}
}
-func rewriteValueWasm_OpMove(v *ssa.Value) bool {
+func rewriteValue_OpMove(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3169,7 +3169,7 @@
}
return false
}
-func rewriteValueWasm_OpNeg16(v *ssa.Value) bool {
+func rewriteValue_OpNeg16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3184,7 +3184,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg32(v *ssa.Value) bool {
+func rewriteValue_OpNeg32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3199,7 +3199,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg64(v *ssa.Value) bool {
+func rewriteValue_OpNeg64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3214,7 +3214,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg8(v *ssa.Value) bool {
+func rewriteValue_OpNeg8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3229,7 +3229,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq16(v *ssa.Value) bool {
+func rewriteValue_OpNeq16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3248,7 +3248,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq32(v *ssa.Value) bool {
+func rewriteValue_OpNeq32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3267,7 +3267,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq8(v *ssa.Value) bool {
+func rewriteValue_OpNeq8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3286,7 +3286,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount16(v *ssa.Value) bool {
+func rewriteValue_OpPopCount16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3301,7 +3301,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount32(v *ssa.Value) bool {
+func rewriteValue_OpPopCount32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3316,7 +3316,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount8(v *ssa.Value) bool {
+func rewriteValue_OpPopCount8(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3331,7 +3331,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3354,7 +3354,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3377,7 +3377,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3400,7 +3400,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3423,7 +3423,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3446,7 +3446,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3469,7 +3469,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3492,7 +3492,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllLeftVarUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllLeftVarUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3515,7 +3515,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3538,7 +3538,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3561,7 +3561,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3584,7 +3584,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3607,7 +3607,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3630,7 +3630,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3653,7 +3653,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3676,7 +3676,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateAllRightVarUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpRotateAllRightVarUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3699,7 +3699,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateLeft16(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3727,7 +3727,7 @@
}
return false
}
-func rewriteValueWasm_OpRotateLeft8(v *ssa.Value) bool {
+func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3755,7 +3755,7 @@
}
return false
}
-func rewriteValueWasm_OpRsh16Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3776,7 +3776,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3797,7 +3797,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3816,7 +3816,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3837,7 +3837,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3858,7 +3858,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3879,7 +3879,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3898,7 +3898,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3919,7 +3919,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3940,7 +3940,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3961,7 +3961,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3980,7 +3980,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4001,7 +4001,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4022,7 +4022,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4043,7 +4043,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4062,7 +4062,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4083,7 +4083,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4102,7 +4102,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4121,7 +4121,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4190,7 +4190,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4209,7 +4209,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4228,7 +4228,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4247,7 +4247,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4319,7 +4319,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4338,7 +4338,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4359,7 +4359,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4380,7 +4380,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4399,7 +4399,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4420,7 +4420,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x16(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4441,7 +4441,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x32(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4462,7 +4462,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x64(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4481,7 +4481,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x8(v *ssa.Value) bool {
+func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4502,7 +4502,7 @@
return true
}
}
-func rewriteValueWasm_OpSelect0(v *ssa.Value) bool {
+func rewriteValue_OpSelect0(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select0 <t> (Mul64uhilo x y))
// result: (Hmul64u <t> x y)
@@ -4520,7 +4520,7 @@
}
return false
}
-func rewriteValueWasm_OpSelect1(v *ssa.Value) bool {
+func rewriteValue_OpSelect1(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (Select1 <t> (Mul64uhilo x y))
// result: (I64Mul x y)
@@ -4536,7 +4536,7 @@
}
return false
}
-func rewriteValueWasm_OpShiftAllLeftInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4595,7 +4595,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4654,7 +4654,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4713,7 +4713,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4772,7 +4772,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4831,7 +4831,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4890,7 +4890,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4949,7 +4949,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllLeftUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllLeftUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5008,7 +5008,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightInt16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5069,7 +5069,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightInt32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5130,7 +5130,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightInt64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5191,7 +5191,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightInt8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightInt8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5252,7 +5252,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightUint16x8(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint16x8(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5311,7 +5311,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightUint32x4(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint32x4(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5370,7 +5370,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightUint64x2(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint64x2(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5429,7 +5429,7 @@
return true
}
}
-func rewriteValueWasm_OpShiftAllRightUint8x16(v *ssa.Value) bool {
+func rewriteValue_OpShiftAllRightUint8x16(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5488,7 +5488,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt16to32(v *ssa.Value) bool {
+func rewriteValue_OpSignExt16to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x:(I64Load16S _ _))
// result: x
@@ -5509,7 +5509,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 x:(I64Load16S _ _))
// result: x
@@ -5530,7 +5530,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 x:(I64Load32S _ _))
// result: x
@@ -5551,7 +5551,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to16(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to16(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x:(I64Load8S _ _))
// result: x
@@ -5572,7 +5572,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to32(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to32(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x:(I64Load8S _ _))
// result: x
@@ -5593,7 +5593,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpSignExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 x:(I64Load8S _ _))
// result: x
@@ -5614,7 +5614,7 @@
return true
}
}
-func rewriteValueWasm_OpSlicemask(v *ssa.Value) bool {
+func rewriteValue_OpSlicemask(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5633,7 +5633,7 @@
return true
}
}
-func rewriteValueWasm_OpStore(v *ssa.Value) bool {
+func rewriteValue_OpStore(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5744,7 +5744,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmF32DemoteF64(v *ssa.Value) bool {
+func rewriteValue_OpWasmF32DemoteF64(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (F32DemoteF64 (F64Sqrt (F64PromoteF32 x)))
// result: (F32Sqrt x)
@@ -5859,7 +5859,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmF64Add(v *ssa.Value) bool {
+func rewriteValue_OpWasmF64Add(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5899,7 +5899,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmF64Mul(v *ssa.Value) bool {
+func rewriteValue_OpWasmF64Mul(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5943,7 +5943,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Add(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Add(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6001,7 +6001,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64AddConst(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64AddConst(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (I64AddConst [0] x)
// result: x
@@ -6049,7 +6049,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64And(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64And(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6132,7 +6132,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Eq(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Eq(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6206,7 +6206,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Eqz(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Eqz(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (I64Eqz (I64Eqz (I64Eqz x)))
// result: (I64Eqz x)
@@ -6225,7 +6225,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Extend16S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Extend16S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (I64Extend16S (I64Extend16S x))
// result: (I64Extend16S x)
@@ -6271,7 +6271,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Extend32S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Extend32S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (I64Extend32S (I64Extend32S x))
// result: (I64Extend32S x)
@@ -6328,7 +6328,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Extend8S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Extend8S(v *ssa.Value) bool {
v_0 := v.Args[0]
// match: (I64Extend8S (I64Extend8S x))
// result: (I64Extend8S x)
@@ -6363,7 +6363,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64LeU(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64LeU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6394,7 +6394,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6438,7 +6438,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load16S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load16S(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6482,7 +6482,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load16U(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load16U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6526,7 +6526,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load32S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load32S(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6570,7 +6570,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load32U(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load32U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6614,7 +6614,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load8S(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load8S(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load8S [off] (I64AddConst [off2] ptr) mem)
@@ -6656,7 +6656,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load8U(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Load8U(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load8U [off] (I64AddConst [off2] ptr) mem)
@@ -6698,7 +6698,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64LtU(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64LtU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6729,7 +6729,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Mul(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Mul(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6789,7 +6789,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Ne(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Ne(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6865,7 +6865,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Or(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Or(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6925,7 +6925,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Shl(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Shl(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Shl (I64Const [x]) (I64Const [y]))
@@ -6945,7 +6945,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64ShrS(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64ShrS(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64ShrS (I64Const [x]) (I64Const [y]))
@@ -6965,7 +6965,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64ShrU(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64ShrU(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64ShrU (I64Const [x]) (I64Const [y]))
@@ -6985,7 +6985,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Store(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7011,7 +7011,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store16(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Store16(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7037,7 +7037,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store32(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Store32(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7063,7 +7063,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store8(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Store8(v *ssa.Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7089,7 +7089,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Sub(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Sub(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Sub (I64Const [x]) (I64Const [y]))
@@ -7109,7 +7109,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Xor(v *ssa.Value) bool {
+func rewriteValue_OpWasmI64Xor(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7159,7 +7159,7 @@
}
return false
}
-func rewriteValueWasm_OpZero(v *ssa.Value) bool {
+func rewriteValue_OpZero(v *ssa.Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7392,7 +7392,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt16to32(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt16to32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7417,7 +7417,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt16to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7442,7 +7442,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt32to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7467,7 +7467,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to16(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to16(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7492,7 +7492,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to32(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to32(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7517,7 +7517,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to64(v *ssa.Value) bool {
+func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7542,6 +7542,6 @@
return true
}
}
-func rewriteBlockWasm(b *ssa.Block) bool {
+func RewriteBlock(b *ssa.Block) bool {
return false
}
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 1827dff..527f074 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -343,7 +343,7 @@
return bootstrapFixImports(srcFile)
}
-var ssaRewriteSplitPackages = false
+var ssaRewriteSplitPackages = true
var (
importRE = regexp.MustCompile(`\Aimport\s+(\.|[A-Za-z0-9_]+)?\s*"([^"]+)"\s*(//.*)?\n\z`)
diff --git a/src/simd/archsimd/_gen/simdgen/main.go b/src/simd/archsimd/_gen/simdgen/main.go
index 1ad3f69..9a20479 100644
--- a/src/simd/archsimd/_gen/simdgen/main.go
+++ b/src/simd/archsimd/_gen/simdgen/main.go
@@ -140,7 +140,7 @@
const simdPackage = "simd/archsimd"
-var splitPhase = phase5Conv
+var splitPhase = phase6Rewrites
var (
title = identity
diff --git a/src/simd/archsimd/_gen/tmplgen/main.go b/src/simd/archsimd/_gen/tmplgen/main.go
index 5c6d13e..86ed965 100644
--- a/src/simd/archsimd/_gen/tmplgen/main.go
+++ b/src/simd/archsimd/_gen/tmplgen/main.go
@@ -1388,7 +1388,7 @@
var SSA = "../../../../cmd/compile/internal/ssa/"
-var splitPhase = phase5Conv
+var splitPhase = phase6Rewrites
var (
splitRewritesPath = "cmd/compile/internal/ssa"
diff --git a/src/simd/archsimd/_gen/wasmgen/main.go b/src/simd/archsimd/_gen/wasmgen/main.go
index 5e454a2..b40f723 100644
--- a/src/simd/archsimd/_gen/wasmgen/main.go
+++ b/src/simd/archsimd/_gen/wasmgen/main.go
@@ -34,7 +34,7 @@
list = flag.Bool("list", false, "list all the opcodes")
)
-var splitPhase = phase5Conv
+var splitPhase = phase6Rewrites
var (
splitOpPath = "cmd/compile/internal/ssa"
