cmd/compile: use unsigned constant when folding loads for SIMD ops with constants

When folding loads into a SIMD op with a constant, in the SSA
rules we use makeValAndOff to create an AuxInt for the constant
and the offset. For the SIMD ops of concern (for now), the
constants are always unsigned. So pass the constant unsigned.

Fixes #76756.

Change-Id: Ia5910e689ff510ce54d3a0c2ed0e950bc54f8862
Reviewed-on: https://go-review.googlesource.com/c/go/+/730420
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

diff --git a/src/cmd/compile/internal/ssa/_gen/simdAMD64.rules b/src/cmd/compile/internal/ssa/_gen/simdAMD64.rules
index 649940497ce42cdf0a1e3caae20a3afd8332fbf3..88d8567a3d045dafa43f28aea9cfe90dac07df48 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/simdAMD64.rules
+++ b/src/cmd/compile/internal/ssa/_gen/simdAMD64.rules
@@ -2511,30 +2511,30 @@
 (VPANDNQMasked128 x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPANDNQMasked128load {sym} [off] x ptr mask mem)
 (VPANDNQMasked256 x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPANDNQMasked256load {sym} [off] x ptr mask mem)
 (VPANDNQMasked512 x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPANDNQMasked512load {sym} [off] x ptr mask mem)
-(VRNDSCALEPS128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPS256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPS512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VRNDSCALEPSMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VRNDSCALEPSMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VRNDSCALEPSMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VRNDSCALEPDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VRNDSCALEPDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VRNDSCALEPDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPS128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPS256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPS512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VREDUCEPSMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPSMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPSMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VREDUCEPDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
+(VRNDSCALEPS128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPS256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPS512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPS512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VRNDSCALEPSMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VRNDSCALEPSMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VRNDSCALEPSMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VRNDSCALEPDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VRNDSCALEPDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VRNDSCALEPDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRNDSCALEPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPS128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPS256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPS512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPS512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VREDUCEPSMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPSMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPSMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VREDUCEPDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VREDUCEPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
 (VPERMI2PS128 x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPERMI2PS128load {sym} [off] x y ptr mem)
 (VPERMI2D128 x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPERMI2D128load {sym} [off] x y ptr mem)
 (VPERMI2PS256 x y l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPERMI2PS256load {sym} [off] x y ptr mem)
@@ -2665,44 +2665,44 @@
 (VPDPBUSDSMasked512 x y l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPDPBUSDSMasked512load {sym} [off] x y ptr mask mem)
 (VPCMPEQD512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPEQD512load {sym} [off] x ptr mem)
 (VPCMPEQQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPEQQ512load {sym} [off] x ptr mem)
-(VCMPPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VCMPPS512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
-(VCMPPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VCMPPD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
-(VCMPPSMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VCMPPSMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VCMPPSMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VCMPPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VCMPPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VCMPPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VPCMPUQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
-(VGF2P8AFFINEQB128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEQB256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEQB512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEINVQB128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEINVQB256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEINVQB512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VGF2P8AFFINEINVQBMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VGF2P8AFFINEINVQBMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VGF2P8AFFINEINVQBMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VGF2P8AFFINEQBMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VGF2P8AFFINEQBMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VGF2P8AFFINEQBMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
+(VCMPPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VCMPPS512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
+(VCMPPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VCMPPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
+(VCMPPSMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VCMPPSMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VCMPPSMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VCMPPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VCMPPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VCMPPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VCMPPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VPCMPUQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
+(VGF2P8AFFINEQB128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEQB256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEQB512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQB512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEINVQB128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEINVQB256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEINVQB512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQB512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VGF2P8AFFINEINVQBMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VGF2P8AFFINEINVQBMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VGF2P8AFFINEINVQBMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEINVQBMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VGF2P8AFFINEQBMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VGF2P8AFFINEQBMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VGF2P8AFFINEQBMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VGF2P8AFFINEQBMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
 (VPCMPGTD512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPGTD512load {sym} [off] x ptr mem)
 (VPCMPGTQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPGTQ512load {sym} [off] x ptr mem)
-(VPCMPUD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPUD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
-(VPCMPUQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
-(VPCMPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
-(VPCMPQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+(VPCMPUD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPUD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
+(VPCMPUQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPUQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
+(VPCMPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
+(VPCMPQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPCMPQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
 (VPUNPCKHDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPUNPCKHDQ512load {sym} [off] x ptr mem)
 (VPUNPCKHQDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPUNPCKHQDQ512load {sym} [off] x ptr mem)
 (VPUNPCKLDQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPUNPCKLDQ512load {sym} [off] x ptr mem)
@@ -2883,30 +2883,30 @@
 (VRSQRT14PDMasked128 l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRSQRT14PDMasked128load {sym} [off] ptr mask mem)
 (VRSQRT14PDMasked256 l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRSQRT14PDMasked256load {sym} [off] ptr mask mem)
 (VRSQRT14PDMasked512 l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VRSQRT14PDMasked512load {sym} [off] ptr mask mem)
-(VPROLD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLQ128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLQ256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLQ512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPROLDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPROLDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPROLDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPROLQMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPROLQMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPROLQMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORQ128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORQ256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORQ512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPRORDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORQMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORQMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPRORQMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
+(VPROLD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLQ128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLQ256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLQ512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLQ512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPROLDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPROLDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPROLDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPROLQMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPROLQMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPROLQMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPROLQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORD128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORD256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORQ128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORQ256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORQ512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPRORQ512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPRORDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORQMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORQMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPRORQMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPRORQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
 (VPROLVD128 x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLVD128load {sym} [off] x ptr mem)
 (VPROLVD256 x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLVD256load {sym} [off] x ptr mem)
 (VPROLVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPROLVD512load {sym} [off] x ptr mem)
@@ -2951,30 +2951,30 @@
 (VSCALEFPDMasked128 x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VSCALEFPDMasked128load {sym} [off] x ptr mask mem)
 (VSCALEFPDMasked256 x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VSCALEFPDMasked256load {sym} [off] x ptr mask mem)
 (VSCALEFPDMasked512 x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VSCALEFPDMasked512load {sym} [off] x ptr mask mem)
-(VPSHLDD128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDD256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDQ128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDQ256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDQ512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHLDDMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHLDDMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHLDDMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHLDQMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHLDQMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHLDQMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDD128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDD256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDQ128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDQ256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDQ512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHRDDMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDDMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDDMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDQMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDQMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
-(VPSHRDQMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mask mem)
+(VPSHLDD128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDD256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDQ128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDQ256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDQ512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQ512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHLDDMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHLDDMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHLDDMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHLDQMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHLDQMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHLDQMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHLDQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDD128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDD256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDQ128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDQ256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDQ512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQ512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHRDDMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDDMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDDMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDQMasked128 [c]  x l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDQMasked256 [c]  x l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
+(VPSHRDQMasked512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHRDQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mask mem)
 (VPSLLVD512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLVD512load {sym} [off] x ptr mem)
 (VPSLLVQ512 x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLVQ512load {sym} [off] x ptr mem)
 (VPSHLDVD128 x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHLDVD128load {sym} [off] x y ptr mem)
@@ -3059,41 +3059,41 @@
 (VPXORQMasked512 x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPXORQMasked512load {sym} [off] x ptr mask mem)
 (VPBLENDMDMasked512 x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPBLENDMDMasked512load {sym} [off] x ptr mask mem)
 (VPBLENDMQMasked512 x l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPBLENDMQMasked512load {sym} [off] x ptr mask mem)
-(VSHUFPS512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VSHUFPS512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VSHUFPD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VSHUFPD512load {sym} [makeValAndOff(int32(int8(c)),off)]  x ptr mem)
-(VPSHUFD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHUFD512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSHUFDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSHUFDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSHUFDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLD512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSLLQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLQ512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSLLDMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLDMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLDMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSLLQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRLD512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRLQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRLQ512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRAD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAD512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRAQ128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRAQ256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRAQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mem)
-(VPSRLDMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLDMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLDMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRLQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRADMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRADMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRADMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRAQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRAQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPSRAQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)]  ptr mask mem)
-(VPTERNLOGD128 [c]  x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD128load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
-(VPTERNLOGD256 [c]  x y l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD256load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
-(VPTERNLOGD512 [c]  x y l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD512load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
-(VPTERNLOGQ128 [c]  x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ128load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
-(VPTERNLOGQ256 [c]  x y l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ256load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
-(VPTERNLOGQ512 [c]  x y l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ512load {sym} [makeValAndOff(int32(int8(c)),off)]  x y ptr mem)
+(VSHUFPS512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VSHUFPS512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VSHUFPD512 [c]  x l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VSHUFPD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x ptr mem)
+(VPSHUFD512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSHUFD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSHUFDMasked256 [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSHUFDMasked512 [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSHUFDMasked128 [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSHUFDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLD512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSLLQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSLLQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSLLDMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLDMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLDMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLDMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSLLQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSLLQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRLD512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRLQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRLQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRAD512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAD512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRAQ128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRAQ256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRAQ512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPSRAQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mem)
+(VPSRLDMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLDMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLDMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLDMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRLQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRLQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRADMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRADMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRADMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRADMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRAQMasked128const [c]  l:(VMOVDQUload128 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRAQMasked256const [c]  l:(VMOVDQUload256 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPSRAQMasked512const [c]  l:(VMOVDQUload512 {sym} [off] ptr mem) mask) && canMergeLoad(v, l) && clobber(l) => (VPSRAQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)]  ptr mask mem)
+(VPTERNLOGD128 [c]  x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)
+(VPTERNLOGD256 [c]  x y l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)
+(VPTERNLOGD512 [c]  x y l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGD512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)
+(VPTERNLOGQ128 [c]  x y l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ128load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)
+(VPTERNLOGQ256 [c]  x y l:(VMOVDQUload256 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ256load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)
+(VPTERNLOGQ512 [c]  x y l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPTERNLOGQ512load {sym} [makeValAndOff(int32(uint8(c)),off)]  x y ptr mem)

diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 19f16e1cbb14a008b4d69bbf63d0d603e28c8031..797757c322f103ed6eec3cd9a1ad19e0985abbab 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -28763,7 +28763,7 @@ func rewriteValueAMD64_OpAMD64VCMPPD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VCMPPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28779,7 +28779,7 @@ func rewriteValueAMD64_OpAMD64VCMPPD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -28792,7 +28792,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28809,7 +28809,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -28822,7 +28822,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28839,7 +28839,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -28852,7 +28852,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28869,7 +28869,7 @@ func rewriteValueAMD64_OpAMD64VCMPPDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -28881,7 +28881,7 @@ func rewriteValueAMD64_OpAMD64VCMPPS512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPS512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VCMPPS512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28897,7 +28897,7 @@ func rewriteValueAMD64_OpAMD64VCMPPS512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPS512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -28910,7 +28910,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPSMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28927,7 +28927,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPSMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -28940,7 +28940,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPSMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28957,7 +28957,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPSMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -28970,7 +28970,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VCMPPSMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VCMPPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VCMPPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -28987,7 +28987,7 @@ func rewriteValueAMD64_OpAMD64VCMPPSMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VCMPPSMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32605,7 +32605,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQB128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQB128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEINVQB128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32621,7 +32621,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQB128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32633,7 +32633,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQB256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQB256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEINVQB256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32649,7 +32649,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQB256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32661,7 +32661,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQB512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQB512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEINVQB512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32677,7 +32677,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQB512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQB512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32690,7 +32690,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQBMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQBMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEINVQBMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32707,7 +32707,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQBMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32720,7 +32720,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQBMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQBMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEINVQBMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32737,7 +32737,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQBMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32750,7 +32750,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEINVQBMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEINVQBMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEINVQBMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32767,7 +32767,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEINVQBMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEINVQBMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32779,7 +32779,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQB128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQB128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEQB128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32795,7 +32795,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQB128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32807,7 +32807,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQB256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQB256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEQB256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32823,7 +32823,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQB256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32835,7 +32835,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQB512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQB512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VGF2P8AFFINEQB512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32851,7 +32851,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQB512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQB512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -32864,7 +32864,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQBMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQBMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEQBMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32881,7 +32881,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQBMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32894,7 +32894,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQBMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQBMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEQBMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32911,7 +32911,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQBMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -32924,7 +32924,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VGF2P8AFFINEQBMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VGF2P8AFFINEQBMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VGF2P8AFFINEQBMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -32941,7 +32941,7 @@ func rewriteValueAMD64_OpAMD64VGF2P8AFFINEQBMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VGF2P8AFFINEQBMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52553,7 +52553,7 @@ func rewriteValueAMD64_OpAMD64VPCMPD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPCMPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52569,7 +52569,7 @@ func rewriteValueAMD64_OpAMD64VPCMPD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -52582,7 +52582,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52599,7 +52599,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52612,7 +52612,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52629,7 +52629,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52642,7 +52642,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52659,7 +52659,7 @@ func rewriteValueAMD64_OpAMD64VPCMPDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52785,7 +52785,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPCMPQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52801,7 +52801,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -52814,7 +52814,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52831,7 +52831,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52844,7 +52844,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52861,7 +52861,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52874,7 +52874,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52891,7 +52891,7 @@ func rewriteValueAMD64_OpAMD64VPCMPQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52903,7 +52903,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPCMPUD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52919,7 +52919,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -52932,7 +52932,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52949,7 +52949,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52962,7 +52962,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -52979,7 +52979,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -52992,7 +52992,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -53009,7 +53009,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -53021,7 +53021,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPCMPUQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -53037,7 +53037,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -53050,7 +53050,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -53067,7 +53067,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -53080,7 +53080,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -53097,7 +53097,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -53110,7 +53110,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPCMPUQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPCMPUQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPCMPUQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -53127,7 +53127,7 @@ func rewriteValueAMD64_OpAMD64VPCMPUQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPCMPUQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -57296,7 +57296,7 @@ func rewriteValueAMD64_OpAMD64VPROLD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLD128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLD128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57311,7 +57311,7 @@ func rewriteValueAMD64_OpAMD64VPROLD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57322,7 +57322,7 @@ func rewriteValueAMD64_OpAMD64VPROLD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLD256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLD256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57337,7 +57337,7 @@ func rewriteValueAMD64_OpAMD64VPROLD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57348,7 +57348,7 @@ func rewriteValueAMD64_OpAMD64VPROLD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLD512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLD512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57363,7 +57363,7 @@ func rewriteValueAMD64_OpAMD64VPROLD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57375,7 +57375,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57391,7 +57391,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57403,7 +57403,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57419,7 +57419,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57431,7 +57431,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57447,7 +57447,7 @@ func rewriteValueAMD64_OpAMD64VPROLDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57458,7 +57458,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQ128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQ128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLQ128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57473,7 +57473,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQ128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57484,7 +57484,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQ256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQ256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLQ256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57499,7 +57499,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQ256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57510,7 +57510,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQ512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQ512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPROLQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57525,7 +57525,7 @@ func rewriteValueAMD64_OpAMD64VPROLQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57537,7 +57537,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57553,7 +57553,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57565,7 +57565,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57581,7 +57581,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57593,7 +57593,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPROLQMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPROLQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPROLQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57609,7 +57609,7 @@ func rewriteValueAMD64_OpAMD64VPROLQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPROLQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -57956,7 +57956,7 @@ func rewriteValueAMD64_OpAMD64VPRORD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORD128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORD128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57971,7 +57971,7 @@ func rewriteValueAMD64_OpAMD64VPRORD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -57982,7 +57982,7 @@ func rewriteValueAMD64_OpAMD64VPRORD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORD256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORD256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -57997,7 +57997,7 @@ func rewriteValueAMD64_OpAMD64VPRORD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -58008,7 +58008,7 @@ func rewriteValueAMD64_OpAMD64VPRORD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORD512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORD512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58023,7 +58023,7 @@ func rewriteValueAMD64_OpAMD64VPRORD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -58035,7 +58035,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58051,7 +58051,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58063,7 +58063,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58079,7 +58079,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58091,7 +58091,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58107,7 +58107,7 @@ func rewriteValueAMD64_OpAMD64VPRORDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58118,7 +58118,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQ128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQ128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORQ128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58133,7 +58133,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQ128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -58144,7 +58144,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQ256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQ256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORQ256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58159,7 +58159,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQ256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -58170,7 +58170,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQ512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQ512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPRORQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58185,7 +58185,7 @@ func rewriteValueAMD64_OpAMD64VPRORQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -58197,7 +58197,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58213,7 +58213,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58225,7 +58225,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58241,7 +58241,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58253,7 +58253,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPRORQMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPRORQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPRORQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -58269,7 +58269,7 @@ func rewriteValueAMD64_OpAMD64VPRORQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPRORQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -58617,7 +58617,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDD128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDD128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58633,7 +58633,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58645,7 +58645,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDD256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDD256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58661,7 +58661,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58673,7 +58673,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58689,7 +58689,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58702,7 +58702,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58719,7 +58719,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -58732,7 +58732,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58749,7 +58749,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -58762,7 +58762,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58779,7 +58779,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -58791,7 +58791,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQ128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQ128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDQ128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58807,7 +58807,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQ128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58819,7 +58819,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQ256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQ256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDQ256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58835,7 +58835,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQ256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58847,7 +58847,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHLDQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58863,7 +58863,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -58876,7 +58876,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58893,7 +58893,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -58906,7 +58906,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58923,7 +58923,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -58936,7 +58936,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHLDQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHLDQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHLDQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -58953,7 +58953,7 @@ func rewriteValueAMD64_OpAMD64VPSHLDQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHLDQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59325,7 +59325,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDD128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDD128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDD128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59341,7 +59341,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59353,7 +59353,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDD256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDD256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDD256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59369,7 +59369,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59381,7 +59381,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59397,7 +59397,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59410,7 +59410,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDDMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59427,7 +59427,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59440,7 +59440,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDDMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59457,7 +59457,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59470,7 +59470,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDDMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59487,7 +59487,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59499,7 +59499,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQ128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQ128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDQ128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59515,7 +59515,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQ128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59527,7 +59527,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQ256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQ256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDQ256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59543,7 +59543,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQ256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59555,7 +59555,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQ512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VPSHRDQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59571,7 +59571,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -59584,7 +59584,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQMasked128 [c] x l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDQMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59601,7 +59601,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59614,7 +59614,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQMasked256 [c] x l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDQMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59631,7 +59631,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -59644,7 +59644,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHRDQMasked512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHRDQMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mask mem)
+       // result: (VPSHRDQMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -59661,7 +59661,7 @@ func rewriteValueAMD64_OpAMD64VPSHRDQMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHRDQMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, ptr, mask, mem)
                return true
@@ -60032,7 +60032,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHUFD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHUFD512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSHUFD512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60047,7 +60047,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHUFD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -60059,7 +60059,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHUFDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHUFDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSHUFDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60075,7 +60075,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHUFDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60087,7 +60087,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHUFDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHUFDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSHUFDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60103,7 +60103,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHUFDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60115,7 +60115,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSHUFDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSHUFDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSHUFDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60131,7 +60131,7 @@ func rewriteValueAMD64_OpAMD64VPSHUFDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSHUFDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60196,7 +60196,7 @@ func rewriteValueAMD64_OpAMD64VPSLLD512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLD512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLD512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSLLD512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60211,7 +60211,7 @@ func rewriteValueAMD64_OpAMD64VPSLLD512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLD512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -60243,7 +60243,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLDMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLDMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLDMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60259,7 +60259,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLDMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60291,7 +60291,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLDMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLDMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLDMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60307,7 +60307,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLDMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60339,7 +60339,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLDMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLDMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLDMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60355,7 +60355,7 @@ func rewriteValueAMD64_OpAMD64VPSLLDMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLDMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60420,7 +60420,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQ512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLQ512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLQ512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSLLQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60435,7 +60435,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQ512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLQ512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -60467,7 +60467,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLQMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60483,7 +60483,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLQMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60515,7 +60515,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLQMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60531,7 +60531,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLQMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60563,7 +60563,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSLLQMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSLLQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSLLQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -60579,7 +60579,7 @@ func rewriteValueAMD64_OpAMD64VPSLLQMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSLLQMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -60986,7 +60986,7 @@ func rewriteValueAMD64_OpAMD64VPSRAD512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAD512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAD512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRAD512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61001,7 +61001,7 @@ func rewriteValueAMD64_OpAMD64VPSRAD512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAD512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61033,7 +61033,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRADMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRADMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRADMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61049,7 +61049,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRADMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61081,7 +61081,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRADMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRADMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRADMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61097,7 +61097,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRADMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61129,7 +61129,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRADMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRADMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRADMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61145,7 +61145,7 @@ func rewriteValueAMD64_OpAMD64VPSRADMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRADMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61174,7 +61174,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQ128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQ128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRAQ128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61189,7 +61189,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQ128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61218,7 +61218,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQ256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQ256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRAQ256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61233,7 +61233,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQ256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61262,7 +61262,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQ512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQ512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRAQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61277,7 +61277,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQ512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQ512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61309,7 +61309,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRAQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61325,7 +61325,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61357,7 +61357,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRAQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61373,7 +61373,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61405,7 +61405,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRAQMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRAQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRAQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61421,7 +61421,7 @@ func rewriteValueAMD64_OpAMD64VPSRAQMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRAQMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61828,7 +61828,7 @@ func rewriteValueAMD64_OpAMD64VPSRLD512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLD512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLD512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRLD512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61843,7 +61843,7 @@ func rewriteValueAMD64_OpAMD64VPSRLD512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLD512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61855,7 +61855,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLDMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLDMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLDMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61871,7 +61871,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLDMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61883,7 +61883,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLDMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLDMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLDMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61899,7 +61899,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLDMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61911,7 +61911,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLDMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLDMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLDMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61927,7 +61927,7 @@ func rewriteValueAMD64_OpAMD64VPSRLDMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLDMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61938,7 +61938,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQ512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLQ512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLQ512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VPSRLQ512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61953,7 +61953,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQ512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLQ512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -61965,7 +61965,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked128const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLQMasked128const [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLQMasked128constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLQMasked128constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -61981,7 +61981,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked128const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLQMasked128constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -61993,7 +61993,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked256const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLQMasked256const [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLQMasked256constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLQMasked256constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -62009,7 +62009,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked256const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLQMasked256constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -62021,7 +62021,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked512const(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPSRLQMasked512const [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPSRLQMasked512constload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VPSRLQMasked512constload {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -62037,7 +62037,7 @@ func rewriteValueAMD64_OpAMD64VPSRLQMasked512const(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPSRLQMasked512constload)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -62506,7 +62506,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGD128 [c] x y l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGD128load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGD128load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62523,7 +62523,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -62536,7 +62536,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGD256 [c] x y l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGD256load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGD256load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62553,7 +62553,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -62566,7 +62566,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGD512 [c] x y l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGD512load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62583,7 +62583,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -62596,7 +62596,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGQ128 [c] x y l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGQ128load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGQ128load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62613,7 +62613,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGQ128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -62626,7 +62626,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGQ256 [c] x y l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGQ256load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGQ256load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62643,7 +62643,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGQ256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -62656,7 +62656,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VPTERNLOGQ512 [c] x y l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VPTERNLOGQ512load {sym} [makeValAndOff(int32(int8(c)),off)] x y ptr mem)
+       // result: (VPTERNLOGQ512load {sym} [makeValAndOff(int32(uint8(c)),off)] x y ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -62673,7 +62673,7 @@ func rewriteValueAMD64_OpAMD64VPTERNLOGQ512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VPTERNLOGQ512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg4(x, y, ptr, mem)
                return true
@@ -63306,7 +63306,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPD128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPD128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63321,7 +63321,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63332,7 +63332,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPD256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPD256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63347,7 +63347,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63358,7 +63358,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPD512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63373,7 +63373,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63385,7 +63385,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63401,7 +63401,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63413,7 +63413,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63429,7 +63429,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63441,7 +63441,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63457,7 +63457,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63468,7 +63468,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPS128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPS128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPS128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63483,7 +63483,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPS128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63494,7 +63494,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPS256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPS256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPS256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63509,7 +63509,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPS256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63520,7 +63520,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPS512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPS512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VREDUCEPS512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63535,7 +63535,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPS512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPS512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63547,7 +63547,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPSMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63563,7 +63563,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPSMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63575,7 +63575,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPSMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63591,7 +63591,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPSMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63603,7 +63603,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VREDUCEPSMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VREDUCEPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VREDUCEPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63619,7 +63619,7 @@ func rewriteValueAMD64_OpAMD64VREDUCEPSMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VREDUCEPSMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63630,7 +63630,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPD128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPD128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPD128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63645,7 +63645,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPD128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63656,7 +63656,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPD256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPD256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPD256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63671,7 +63671,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPD256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63682,7 +63682,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPD512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPD512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63697,7 +63697,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63709,7 +63709,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPDMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPDMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPDMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63725,7 +63725,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPDMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63737,7 +63737,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPDMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPDMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPDMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63753,7 +63753,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPDMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63765,7 +63765,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPDMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPDMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPDMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63781,7 +63781,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPDMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPDMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63792,7 +63792,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPS128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPS128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPS128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63807,7 +63807,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPS128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63818,7 +63818,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPS256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPS256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPS256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63833,7 +63833,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPS256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63844,7 +63844,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPS512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPS512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
+       // result: (VRNDSCALEPS512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63859,7 +63859,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPS512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPS512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg2(ptr, mem)
                return true
@@ -63871,7 +63871,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked128(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPSMasked128 [c] l:(VMOVDQUload128 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPSMasked128load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPSMasked128load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63887,7 +63887,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked128(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPSMasked128load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63899,7 +63899,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked256(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPSMasked256 [c] l:(VMOVDQUload256 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPSMasked256load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPSMasked256load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63915,7 +63915,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked256(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPSMasked256load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -63927,7 +63927,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VRNDSCALEPSMasked512 [c] l:(VMOVDQUload512 {sym} [off] ptr mem) mask)
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VRNDSCALEPSMasked512load {sym} [makeValAndOff(int32(int8(c)),off)] ptr mask mem)
+       // result: (VRNDSCALEPSMasked512load {sym} [makeValAndOff(int32(uint8(c)),off)] ptr mask mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                l := v_0
@@ -63943,7 +63943,7 @@ func rewriteValueAMD64_OpAMD64VRNDSCALEPSMasked512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VRNDSCALEPSMasked512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(ptr, mask, mem)
                return true
@@ -64553,7 +64553,7 @@ func rewriteValueAMD64_OpAMD64VSHUFPD512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VSHUFPD512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VSHUFPD512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VSHUFPD512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -64569,7 +64569,7 @@ func rewriteValueAMD64_OpAMD64VSHUFPD512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VSHUFPD512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true
@@ -64581,7 +64581,7 @@ func rewriteValueAMD64_OpAMD64VSHUFPS512(v *Value) bool {
        v_0 := v.Args[0]
        // match: (VSHUFPS512 [c] x l:(VMOVDQUload512 {sym} [off] ptr mem))
        // cond: canMergeLoad(v, l) && clobber(l)
-       // result: (VSHUFPS512load {sym} [makeValAndOff(int32(int8(c)),off)] x ptr mem)
+       // result: (VSHUFPS512load {sym} [makeValAndOff(int32(uint8(c)),off)] x ptr mem)
        for {
                c := auxIntToUint8(v.AuxInt)
                x := v_0
@@ -64597,7 +64597,7 @@ func rewriteValueAMD64_OpAMD64VSHUFPS512(v *Value) bool {
                        break
                }
                v.reset(OpAMD64VSHUFPS512load)
-               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
+               v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(uint8(c)), off))
                v.Aux = symToAux(sym)
                v.AddArg3(x, ptr, mem)
                return true

diff --git a/src/simd/archsimd/_gen/simdgen/gen_simdrules.go b/src/simd/archsimd/_gen/simdgen/gen_simdrules.go
index 90c3fb620e52a07c7fb7c263b049ae9faca29e39..7a8823483a6d702aaa5fa52c04f9edca644ba75c 100644 (file)
--- a/src/simd/archsimd/_gen/simdgen/gen_simdrules.go
+++ b/src/simd/archsimd/_gen/simdgen/gen_simdrules.go
@@ -275,7 +275,7 @@ func writeSIMDRules(ops []Operation) *bytes.Buffer {
                                                origArgs = after
                                        }
                                        immArg = "[c] "
-                                       immArgCombineOff = " [makeValAndOff(int32(int8(c)),off)] "
+                                       immArgCombineOff = " [makeValAndOff(int32(uint8(c)),off)] "
                                }
                                memOpData.ArgsLoadAddr = immArg + origArgs + fmt.Sprintf("l:(VMOVDQUload%d {sym} [off] ptr mem)", *lastVreg.Bits)
                                // Remove the last vreg from the arg and change it to "ptr".