ssa.OpAMD64VPABSWMasked256,
ssa.OpAMD64VPABSWMasked512,
ssa.OpAMD64VPABSDMasked128,
+ ssa.OpAMD64VPABSDMasked128load,
ssa.OpAMD64VPABSDMasked256,
+ ssa.OpAMD64VPABSDMasked256load,
ssa.OpAMD64VPABSDMasked512,
+ ssa.OpAMD64VPABSDMasked512load,
ssa.OpAMD64VPABSQMasked128,
+ ssa.OpAMD64VPABSQMasked128load,
ssa.OpAMD64VPABSQMasked256,
+ ssa.OpAMD64VPABSQMasked256load,
ssa.OpAMD64VPABSQMasked512,
+ ssa.OpAMD64VPABSQMasked512load,
ssa.OpAMD64VPDPWSSDMasked128,
+ ssa.OpAMD64VPDPWSSDMasked128load,
ssa.OpAMD64VPDPWSSDMasked256,
+ ssa.OpAMD64VPDPWSSDMasked256load,
ssa.OpAMD64VPDPWSSDMasked512,
+ ssa.OpAMD64VPDPWSSDMasked512load,
ssa.OpAMD64VPDPBUSDMasked128,
+ ssa.OpAMD64VPDPBUSDMasked128load,
ssa.OpAMD64VPDPBUSDMasked256,
+ ssa.OpAMD64VPDPBUSDMasked256load,
ssa.OpAMD64VPDPBUSDMasked512,
+ ssa.OpAMD64VPDPBUSDMasked512load,
ssa.OpAMD64VPDPBUSDSMasked128,
+ ssa.OpAMD64VPDPBUSDSMasked128load,
ssa.OpAMD64VPDPBUSDSMasked256,
+ ssa.OpAMD64VPDPBUSDSMasked256load,
ssa.OpAMD64VPDPBUSDSMasked512,
+ ssa.OpAMD64VPDPBUSDSMasked512load,
ssa.OpAMD64VADDPSMasked128,
+ ssa.OpAMD64VADDPSMasked128load,
ssa.OpAMD64VADDPSMasked256,
+ ssa.OpAMD64VADDPSMasked256load,
ssa.OpAMD64VADDPSMasked512,
+ ssa.OpAMD64VADDPSMasked512load,
ssa.OpAMD64VADDPDMasked128,
+ ssa.OpAMD64VADDPDMasked128load,
ssa.OpAMD64VADDPDMasked256,
+ ssa.OpAMD64VADDPDMasked256load,
ssa.OpAMD64VADDPDMasked512,
+ ssa.OpAMD64VADDPDMasked512load,
ssa.OpAMD64VPADDBMasked128,
ssa.OpAMD64VPADDBMasked256,
ssa.OpAMD64VPADDBMasked512,
ssa.OpAMD64VPADDWMasked256,
ssa.OpAMD64VPADDWMasked512,
ssa.OpAMD64VPADDDMasked128,
+ ssa.OpAMD64VPADDDMasked128load,
ssa.OpAMD64VPADDDMasked256,
+ ssa.OpAMD64VPADDDMasked256load,
ssa.OpAMD64VPADDDMasked512,
+ ssa.OpAMD64VPADDDMasked512load,
ssa.OpAMD64VPADDQMasked128,
+ ssa.OpAMD64VPADDQMasked128load,
ssa.OpAMD64VPADDQMasked256,
+ ssa.OpAMD64VPADDQMasked256load,
ssa.OpAMD64VPADDQMasked512,
+ ssa.OpAMD64VPADDQMasked512load,
ssa.OpAMD64VPADDSBMasked128,
ssa.OpAMD64VPADDSBMasked256,
ssa.OpAMD64VPADDSBMasked512,
ssa.OpAMD64VPADDUSWMasked256,
ssa.OpAMD64VPADDUSWMasked512,
ssa.OpAMD64VPANDDMasked128,
+ ssa.OpAMD64VPANDDMasked128load,
ssa.OpAMD64VPANDDMasked256,
+ ssa.OpAMD64VPANDDMasked256load,
ssa.OpAMD64VPANDDMasked512,
+ ssa.OpAMD64VPANDDMasked512load,
ssa.OpAMD64VPANDQMasked128,
+ ssa.OpAMD64VPANDQMasked128load,
ssa.OpAMD64VPANDQMasked256,
+ ssa.OpAMD64VPANDQMasked256load,
ssa.OpAMD64VPANDQMasked512,
+ ssa.OpAMD64VPANDQMasked512load,
ssa.OpAMD64VPANDNDMasked128,
+ ssa.OpAMD64VPANDNDMasked128load,
ssa.OpAMD64VPANDNDMasked256,
+ ssa.OpAMD64VPANDNDMasked256load,
ssa.OpAMD64VPANDNDMasked512,
+ ssa.OpAMD64VPANDNDMasked512load,
ssa.OpAMD64VPANDNQMasked128,
+ ssa.OpAMD64VPANDNQMasked128load,
ssa.OpAMD64VPANDNQMasked256,
+ ssa.OpAMD64VPANDNQMasked256load,
ssa.OpAMD64VPANDNQMasked512,
+ ssa.OpAMD64VPANDNQMasked512load,
ssa.OpAMD64VPAVGBMasked128,
ssa.OpAMD64VPAVGBMasked256,
ssa.OpAMD64VPAVGBMasked512,
ssa.OpAMD64VPBROADCASTDMasked512,
ssa.OpAMD64VPBROADCASTQMasked512,
ssa.OpAMD64VRNDSCALEPSMasked128,
+ ssa.OpAMD64VRNDSCALEPSMasked128load,
ssa.OpAMD64VRNDSCALEPSMasked256,
+ ssa.OpAMD64VRNDSCALEPSMasked256load,
ssa.OpAMD64VRNDSCALEPSMasked512,
+ ssa.OpAMD64VRNDSCALEPSMasked512load,
ssa.OpAMD64VRNDSCALEPDMasked128,
+ ssa.OpAMD64VRNDSCALEPDMasked128load,
ssa.OpAMD64VRNDSCALEPDMasked256,
+ ssa.OpAMD64VRNDSCALEPDMasked256load,
ssa.OpAMD64VRNDSCALEPDMasked512,
+ ssa.OpAMD64VRNDSCALEPDMasked512load,
ssa.OpAMD64VREDUCEPSMasked128,
+ ssa.OpAMD64VREDUCEPSMasked128load,
ssa.OpAMD64VREDUCEPSMasked256,
+ ssa.OpAMD64VREDUCEPSMasked256load,
ssa.OpAMD64VREDUCEPSMasked512,
+ ssa.OpAMD64VREDUCEPSMasked512load,
ssa.OpAMD64VREDUCEPDMasked128,
+ ssa.OpAMD64VREDUCEPDMasked128load,
ssa.OpAMD64VREDUCEPDMasked256,
+ ssa.OpAMD64VREDUCEPDMasked256load,
ssa.OpAMD64VREDUCEPDMasked512,
+ ssa.OpAMD64VREDUCEPDMasked512load,
ssa.OpAMD64VCOMPRESSPSMasked128,
ssa.OpAMD64VCOMPRESSPSMasked256,
ssa.OpAMD64VCOMPRESSPSMasked512,
ssa.OpAMD64VPMOVSDWMasked256,
ssa.OpAMD64VPMOVSQWMasked128,
ssa.OpAMD64VPACKSSDWMasked128,
+ ssa.OpAMD64VPACKSSDWMasked128load,
ssa.OpAMD64VPACKSSDWMasked256,
+ ssa.OpAMD64VPACKSSDWMasked256load,
ssa.OpAMD64VPACKSSDWMasked512,
+ ssa.OpAMD64VPACKSSDWMasked512load,
ssa.OpAMD64VPMOVSXBWMasked128,
ssa.OpAMD64VCVTTPS2DQMasked128,
+ ssa.OpAMD64VCVTTPS2DQMasked128load,
ssa.OpAMD64VCVTTPS2DQMasked256,
+ ssa.OpAMD64VCVTTPS2DQMasked256load,
ssa.OpAMD64VCVTTPS2DQMasked512,
+ ssa.OpAMD64VCVTTPS2DQMasked512load,
ssa.OpAMD64VPMOVSXBDMasked512,
ssa.OpAMD64VPMOVSXWDMasked256,
ssa.OpAMD64VPMOVSXWDMasked512,
ssa.OpAMD64VPMOVUSDWMasked256,
ssa.OpAMD64VPMOVUSQWMasked128,
ssa.OpAMD64VPACKUSDWMasked128,
+ ssa.OpAMD64VPACKUSDWMasked128load,
ssa.OpAMD64VPACKUSDWMasked256,
+ ssa.OpAMD64VPACKUSDWMasked256load,
ssa.OpAMD64VPACKUSDWMasked512,
+ ssa.OpAMD64VPACKUSDWMasked512load,
ssa.OpAMD64VPMOVZXBWMasked128,
ssa.OpAMD64VCVTPS2UDQMasked128,
+ ssa.OpAMD64VCVTPS2UDQMasked128load,
ssa.OpAMD64VCVTPS2UDQMasked256,
+ ssa.OpAMD64VCVTPS2UDQMasked256load,
ssa.OpAMD64VCVTPS2UDQMasked512,
+ ssa.OpAMD64VCVTPS2UDQMasked512load,
ssa.OpAMD64VPMOVZXBDMasked512,
ssa.OpAMD64VPMOVZXWDMasked256,
ssa.OpAMD64VPMOVZXWDMasked512,
ssa.OpAMD64VPMOVZXWQMasked256,
ssa.OpAMD64VPMOVZXBQMasked512,
ssa.OpAMD64VDIVPSMasked128,
+ ssa.OpAMD64VDIVPSMasked128load,
ssa.OpAMD64VDIVPSMasked256,
+ ssa.OpAMD64VDIVPSMasked256load,
ssa.OpAMD64VDIVPSMasked512,
+ ssa.OpAMD64VDIVPSMasked512load,
ssa.OpAMD64VDIVPDMasked128,
+ ssa.OpAMD64VDIVPDMasked128load,
ssa.OpAMD64VDIVPDMasked256,
+ ssa.OpAMD64VDIVPDMasked256load,
ssa.OpAMD64VDIVPDMasked512,
+ ssa.OpAMD64VDIVPDMasked512load,
ssa.OpAMD64VPMADDWDMasked128,
ssa.OpAMD64VPMADDWDMasked256,
ssa.OpAMD64VPMADDWDMasked512,
ssa.OpAMD64VPEXPANDQMasked256,
ssa.OpAMD64VPEXPANDQMasked512,
ssa.OpAMD64VGF2P8AFFINEINVQBMasked128,
+ ssa.OpAMD64VGF2P8AFFINEINVQBMasked128load,
ssa.OpAMD64VGF2P8AFFINEINVQBMasked256,
+ ssa.OpAMD64VGF2P8AFFINEINVQBMasked256load,
ssa.OpAMD64VGF2P8AFFINEINVQBMasked512,
+ ssa.OpAMD64VGF2P8AFFINEINVQBMasked512load,
ssa.OpAMD64VGF2P8AFFINEQBMasked128,
+ ssa.OpAMD64VGF2P8AFFINEQBMasked128load,
ssa.OpAMD64VGF2P8AFFINEQBMasked256,
+ ssa.OpAMD64VGF2P8AFFINEQBMasked256load,
ssa.OpAMD64VGF2P8AFFINEQBMasked512,
+ ssa.OpAMD64VGF2P8AFFINEQBMasked512load,
ssa.OpAMD64VGF2P8MULBMasked128,
ssa.OpAMD64VGF2P8MULBMasked256,
ssa.OpAMD64VGF2P8MULBMasked512,
ssa.OpAMD64VPLZCNTDMasked128,
+ ssa.OpAMD64VPLZCNTDMasked128load,
ssa.OpAMD64VPLZCNTDMasked256,
+ ssa.OpAMD64VPLZCNTDMasked256load,
ssa.OpAMD64VPLZCNTDMasked512,
+ ssa.OpAMD64VPLZCNTDMasked512load,
ssa.OpAMD64VPLZCNTQMasked128,
+ ssa.OpAMD64VPLZCNTQMasked128load,
ssa.OpAMD64VPLZCNTQMasked256,
+ ssa.OpAMD64VPLZCNTQMasked256load,
ssa.OpAMD64VPLZCNTQMasked512,
+ ssa.OpAMD64VPLZCNTQMasked512load,
ssa.OpAMD64VMAXPSMasked128,
+ ssa.OpAMD64VMAXPSMasked128load,
ssa.OpAMD64VMAXPSMasked256,
+ ssa.OpAMD64VMAXPSMasked256load,
ssa.OpAMD64VMAXPSMasked512,
+ ssa.OpAMD64VMAXPSMasked512load,
ssa.OpAMD64VMAXPDMasked128,
+ ssa.OpAMD64VMAXPDMasked128load,
ssa.OpAMD64VMAXPDMasked256,
+ ssa.OpAMD64VMAXPDMasked256load,
ssa.OpAMD64VMAXPDMasked512,
+ ssa.OpAMD64VMAXPDMasked512load,
ssa.OpAMD64VPMAXSBMasked128,
ssa.OpAMD64VPMAXSBMasked256,
ssa.OpAMD64VPMAXSBMasked512,
ssa.OpAMD64VPMAXSWMasked256,
ssa.OpAMD64VPMAXSWMasked512,
ssa.OpAMD64VPMAXSDMasked128,
+ ssa.OpAMD64VPMAXSDMasked128load,
ssa.OpAMD64VPMAXSDMasked256,
+ ssa.OpAMD64VPMAXSDMasked256load,
ssa.OpAMD64VPMAXSDMasked512,
+ ssa.OpAMD64VPMAXSDMasked512load,
ssa.OpAMD64VPMAXSQMasked128,
+ ssa.OpAMD64VPMAXSQMasked128load,
ssa.OpAMD64VPMAXSQMasked256,
+ ssa.OpAMD64VPMAXSQMasked256load,
ssa.OpAMD64VPMAXSQMasked512,
+ ssa.OpAMD64VPMAXSQMasked512load,
ssa.OpAMD64VPMAXUBMasked128,
ssa.OpAMD64VPMAXUBMasked256,
ssa.OpAMD64VPMAXUBMasked512,
ssa.OpAMD64VPMAXUWMasked256,
ssa.OpAMD64VPMAXUWMasked512,
ssa.OpAMD64VPMAXUDMasked128,
+ ssa.OpAMD64VPMAXUDMasked128load,
ssa.OpAMD64VPMAXUDMasked256,
+ ssa.OpAMD64VPMAXUDMasked256load,
ssa.OpAMD64VPMAXUDMasked512,
+ ssa.OpAMD64VPMAXUDMasked512load,
ssa.OpAMD64VPMAXUQMasked128,
+ ssa.OpAMD64VPMAXUQMasked128load,
ssa.OpAMD64VPMAXUQMasked256,
+ ssa.OpAMD64VPMAXUQMasked256load,
ssa.OpAMD64VPMAXUQMasked512,
+ ssa.OpAMD64VPMAXUQMasked512load,
ssa.OpAMD64VMINPSMasked128,
+ ssa.OpAMD64VMINPSMasked128load,
ssa.OpAMD64VMINPSMasked256,
+ ssa.OpAMD64VMINPSMasked256load,
ssa.OpAMD64VMINPSMasked512,
+ ssa.OpAMD64VMINPSMasked512load,
ssa.OpAMD64VMINPDMasked128,
+ ssa.OpAMD64VMINPDMasked128load,
ssa.OpAMD64VMINPDMasked256,
+ ssa.OpAMD64VMINPDMasked256load,
ssa.OpAMD64VMINPDMasked512,
+ ssa.OpAMD64VMINPDMasked512load,
ssa.OpAMD64VPMINSBMasked128,
ssa.OpAMD64VPMINSBMasked256,
ssa.OpAMD64VPMINSBMasked512,
ssa.OpAMD64VPMINSWMasked256,
ssa.OpAMD64VPMINSWMasked512,
ssa.OpAMD64VPMINSDMasked128,
+ ssa.OpAMD64VPMINSDMasked128load,
ssa.OpAMD64VPMINSDMasked256,
+ ssa.OpAMD64VPMINSDMasked256load,
ssa.OpAMD64VPMINSDMasked512,
+ ssa.OpAMD64VPMINSDMasked512load,
ssa.OpAMD64VPMINSQMasked128,
+ ssa.OpAMD64VPMINSQMasked128load,
ssa.OpAMD64VPMINSQMasked256,
+ ssa.OpAMD64VPMINSQMasked256load,
ssa.OpAMD64VPMINSQMasked512,
+ ssa.OpAMD64VPMINSQMasked512load,
ssa.OpAMD64VPMINUBMasked128,
ssa.OpAMD64VPMINUBMasked256,
ssa.OpAMD64VPMINUBMasked512,
ssa.OpAMD64VPMINUWMasked256,
ssa.OpAMD64VPMINUWMasked512,
ssa.OpAMD64VPMINUDMasked128,
+ ssa.OpAMD64VPMINUDMasked128load,
ssa.OpAMD64VPMINUDMasked256,
+ ssa.OpAMD64VPMINUDMasked256load,
ssa.OpAMD64VPMINUDMasked512,
+ ssa.OpAMD64VPMINUDMasked512load,
ssa.OpAMD64VPMINUQMasked128,
+ ssa.OpAMD64VPMINUQMasked128load,
ssa.OpAMD64VPMINUQMasked256,
+ ssa.OpAMD64VPMINUQMasked256load,
ssa.OpAMD64VPMINUQMasked512,
+ ssa.OpAMD64VPMINUQMasked512load,
ssa.OpAMD64VFMADD213PSMasked128,
+ ssa.OpAMD64VFMADD213PSMasked128load,
ssa.OpAMD64VFMADD213PSMasked256,
+ ssa.OpAMD64VFMADD213PSMasked256load,
ssa.OpAMD64VFMADD213PSMasked512,
+ ssa.OpAMD64VFMADD213PSMasked512load,
ssa.OpAMD64VFMADD213PDMasked128,
+ ssa.OpAMD64VFMADD213PDMasked128load,
ssa.OpAMD64VFMADD213PDMasked256,
+ ssa.OpAMD64VFMADD213PDMasked256load,
ssa.OpAMD64VFMADD213PDMasked512,
+ ssa.OpAMD64VFMADD213PDMasked512load,
ssa.OpAMD64VFMADDSUB213PSMasked128,
+ ssa.OpAMD64VFMADDSUB213PSMasked128load,
ssa.OpAMD64VFMADDSUB213PSMasked256,
+ ssa.OpAMD64VFMADDSUB213PSMasked256load,
ssa.OpAMD64VFMADDSUB213PSMasked512,
+ ssa.OpAMD64VFMADDSUB213PSMasked512load,
ssa.OpAMD64VFMADDSUB213PDMasked128,
+ ssa.OpAMD64VFMADDSUB213PDMasked128load,
ssa.OpAMD64VFMADDSUB213PDMasked256,
+ ssa.OpAMD64VFMADDSUB213PDMasked256load,
ssa.OpAMD64VFMADDSUB213PDMasked512,
+ ssa.OpAMD64VFMADDSUB213PDMasked512load,
ssa.OpAMD64VPMULHWMasked128,
ssa.OpAMD64VPMULHWMasked256,
ssa.OpAMD64VPMULHWMasked512,
ssa.OpAMD64VPMULHUWMasked256,
ssa.OpAMD64VPMULHUWMasked512,
ssa.OpAMD64VMULPSMasked128,
+ ssa.OpAMD64VMULPSMasked128load,
ssa.OpAMD64VMULPSMasked256,
+ ssa.OpAMD64VMULPSMasked256load,
ssa.OpAMD64VMULPSMasked512,
+ ssa.OpAMD64VMULPSMasked512load,
ssa.OpAMD64VMULPDMasked128,
+ ssa.OpAMD64VMULPDMasked128load,
ssa.OpAMD64VMULPDMasked256,
+ ssa.OpAMD64VMULPDMasked256load,
ssa.OpAMD64VMULPDMasked512,
+ ssa.OpAMD64VMULPDMasked512load,
ssa.OpAMD64VPMULLWMasked128,
ssa.OpAMD64VPMULLWMasked256,
ssa.OpAMD64VPMULLWMasked512,
ssa.OpAMD64VPMULLDMasked128,
+ ssa.OpAMD64VPMULLDMasked128load,
ssa.OpAMD64VPMULLDMasked256,
+ ssa.OpAMD64VPMULLDMasked256load,
ssa.OpAMD64VPMULLDMasked512,
+ ssa.OpAMD64VPMULLDMasked512load,
ssa.OpAMD64VPMULLQMasked128,
+ ssa.OpAMD64VPMULLQMasked128load,
ssa.OpAMD64VPMULLQMasked256,
+ ssa.OpAMD64VPMULLQMasked256load,
ssa.OpAMD64VPMULLQMasked512,
+ ssa.OpAMD64VPMULLQMasked512load,
ssa.OpAMD64VFMSUBADD213PSMasked128,
+ ssa.OpAMD64VFMSUBADD213PSMasked128load,
ssa.OpAMD64VFMSUBADD213PSMasked256,
+ ssa.OpAMD64VFMSUBADD213PSMasked256load,
ssa.OpAMD64VFMSUBADD213PSMasked512,
+ ssa.OpAMD64VFMSUBADD213PSMasked512load,
ssa.OpAMD64VFMSUBADD213PDMasked128,
+ ssa.OpAMD64VFMSUBADD213PDMasked128load,
ssa.OpAMD64VFMSUBADD213PDMasked256,
+ ssa.OpAMD64VFMSUBADD213PDMasked256load,
ssa.OpAMD64VFMSUBADD213PDMasked512,
+ ssa.OpAMD64VFMSUBADD213PDMasked512load,
ssa.OpAMD64VPOPCNTBMasked128,
ssa.OpAMD64VPOPCNTBMasked256,
ssa.OpAMD64VPOPCNTBMasked512,
ssa.OpAMD64VPOPCNTWMasked256,
ssa.OpAMD64VPOPCNTWMasked512,
ssa.OpAMD64VPOPCNTDMasked128,
+ ssa.OpAMD64VPOPCNTDMasked128load,
ssa.OpAMD64VPOPCNTDMasked256,
+ ssa.OpAMD64VPOPCNTDMasked256load,
ssa.OpAMD64VPOPCNTDMasked512,
+ ssa.OpAMD64VPOPCNTDMasked512load,
ssa.OpAMD64VPOPCNTQMasked128,
+ ssa.OpAMD64VPOPCNTQMasked128load,
ssa.OpAMD64VPOPCNTQMasked256,
+ ssa.OpAMD64VPOPCNTQMasked256load,
ssa.OpAMD64VPOPCNTQMasked512,
+ ssa.OpAMD64VPOPCNTQMasked512load,
ssa.OpAMD64VPORDMasked128,
+ ssa.OpAMD64VPORDMasked128load,
ssa.OpAMD64VPORDMasked256,
+ ssa.OpAMD64VPORDMasked256load,
ssa.OpAMD64VPORDMasked512,
+ ssa.OpAMD64VPORDMasked512load,
ssa.OpAMD64VPORQMasked128,
+ ssa.OpAMD64VPORQMasked128load,
ssa.OpAMD64VPORQMasked256,
+ ssa.OpAMD64VPORQMasked256load,
ssa.OpAMD64VPORQMasked512,
+ ssa.OpAMD64VPORQMasked512load,
ssa.OpAMD64VPERMI2BMasked128,
ssa.OpAMD64VPERMI2BMasked256,
ssa.OpAMD64VPERMI2BMasked512,
ssa.OpAMD64VPERMI2WMasked256,
ssa.OpAMD64VPERMI2WMasked512,
ssa.OpAMD64VPERMI2PSMasked128,
+ ssa.OpAMD64VPERMI2PSMasked128load,
ssa.OpAMD64VPERMI2DMasked128,
+ ssa.OpAMD64VPERMI2DMasked128load,
ssa.OpAMD64VPERMI2PSMasked256,
+ ssa.OpAMD64VPERMI2PSMasked256load,
ssa.OpAMD64VPERMI2DMasked256,
+ ssa.OpAMD64VPERMI2DMasked256load,
ssa.OpAMD64VPERMI2PSMasked512,
+ ssa.OpAMD64VPERMI2PSMasked512load,
ssa.OpAMD64VPERMI2DMasked512,
+ ssa.OpAMD64VPERMI2DMasked512load,
ssa.OpAMD64VPERMI2PDMasked128,
+ ssa.OpAMD64VPERMI2PDMasked128load,
ssa.OpAMD64VPERMI2QMasked128,
+ ssa.OpAMD64VPERMI2QMasked128load,
ssa.OpAMD64VPERMI2PDMasked256,
+ ssa.OpAMD64VPERMI2PDMasked256load,
ssa.OpAMD64VPERMI2QMasked256,
+ ssa.OpAMD64VPERMI2QMasked256load,
ssa.OpAMD64VPERMI2PDMasked512,
+ ssa.OpAMD64VPERMI2PDMasked512load,
ssa.OpAMD64VPERMI2QMasked512,
+ ssa.OpAMD64VPERMI2QMasked512load,
ssa.OpAMD64VPSHUFDMasked256,
+ ssa.OpAMD64VPSHUFDMasked256load,
ssa.OpAMD64VPSHUFDMasked512,
+ ssa.OpAMD64VPSHUFDMasked512load,
ssa.OpAMD64VPSHUFHWMasked256,
ssa.OpAMD64VPSHUFHWMasked512,
ssa.OpAMD64VPSHUFHWMasked128,
ssa.OpAMD64VPSHUFDMasked128,
+ ssa.OpAMD64VPSHUFDMasked128load,
ssa.OpAMD64VPSHUFBMasked256,
ssa.OpAMD64VPSHUFBMasked512,
ssa.OpAMD64VPSHUFBMasked128,
ssa.OpAMD64VPERMWMasked256,
ssa.OpAMD64VPERMWMasked512,
ssa.OpAMD64VPERMPSMasked256,
+ ssa.OpAMD64VPERMPSMasked256load,
ssa.OpAMD64VPERMDMasked256,
+ ssa.OpAMD64VPERMDMasked256load,
ssa.OpAMD64VPERMPSMasked512,
+ ssa.OpAMD64VPERMPSMasked512load,
ssa.OpAMD64VPERMDMasked512,
+ ssa.OpAMD64VPERMDMasked512load,
ssa.OpAMD64VPERMPDMasked256,
+ ssa.OpAMD64VPERMPDMasked256load,
ssa.OpAMD64VPERMQMasked256,
+ ssa.OpAMD64VPERMQMasked256load,
ssa.OpAMD64VPERMPDMasked512,
+ ssa.OpAMD64VPERMPDMasked512load,
ssa.OpAMD64VPERMQMasked512,
+ ssa.OpAMD64VPERMQMasked512load,
ssa.OpAMD64VRCP14PSMasked128,
+ ssa.OpAMD64VRCP14PSMasked128load,
ssa.OpAMD64VRCP14PSMasked256,
+ ssa.OpAMD64VRCP14PSMasked256load,
ssa.OpAMD64VRCP14PSMasked512,
+ ssa.OpAMD64VRCP14PSMasked512load,
ssa.OpAMD64VRCP14PDMasked128,
+ ssa.OpAMD64VRCP14PDMasked128load,
ssa.OpAMD64VRCP14PDMasked256,
+ ssa.OpAMD64VRCP14PDMasked256load,
ssa.OpAMD64VRCP14PDMasked512,
+ ssa.OpAMD64VRCP14PDMasked512load,
ssa.OpAMD64VRSQRT14PSMasked128,
+ ssa.OpAMD64VRSQRT14PSMasked128load,
ssa.OpAMD64VRSQRT14PSMasked256,
+ ssa.OpAMD64VRSQRT14PSMasked256load,
ssa.OpAMD64VRSQRT14PSMasked512,
+ ssa.OpAMD64VRSQRT14PSMasked512load,
ssa.OpAMD64VRSQRT14PDMasked128,
+ ssa.OpAMD64VRSQRT14PDMasked128load,
ssa.OpAMD64VRSQRT14PDMasked256,
+ ssa.OpAMD64VRSQRT14PDMasked256load,
ssa.OpAMD64VRSQRT14PDMasked512,
+ ssa.OpAMD64VRSQRT14PDMasked512load,
ssa.OpAMD64VPROLDMasked128,
+ ssa.OpAMD64VPROLDMasked128load,
ssa.OpAMD64VPROLDMasked256,
+ ssa.OpAMD64VPROLDMasked256load,
ssa.OpAMD64VPROLDMasked512,
+ ssa.OpAMD64VPROLDMasked512load,
ssa.OpAMD64VPROLQMasked128,
+ ssa.OpAMD64VPROLQMasked128load,
ssa.OpAMD64VPROLQMasked256,
+ ssa.OpAMD64VPROLQMasked256load,
ssa.OpAMD64VPROLQMasked512,
+ ssa.OpAMD64VPROLQMasked512load,
ssa.OpAMD64VPRORDMasked128,
+ ssa.OpAMD64VPRORDMasked128load,
ssa.OpAMD64VPRORDMasked256,
+ ssa.OpAMD64VPRORDMasked256load,
ssa.OpAMD64VPRORDMasked512,
+ ssa.OpAMD64VPRORDMasked512load,
ssa.OpAMD64VPRORQMasked128,
+ ssa.OpAMD64VPRORQMasked128load,
ssa.OpAMD64VPRORQMasked256,
+ ssa.OpAMD64VPRORQMasked256load,
ssa.OpAMD64VPRORQMasked512,
+ ssa.OpAMD64VPRORQMasked512load,
ssa.OpAMD64VPROLVDMasked128,
+ ssa.OpAMD64VPROLVDMasked128load,
ssa.OpAMD64VPROLVDMasked256,
+ ssa.OpAMD64VPROLVDMasked256load,
ssa.OpAMD64VPROLVDMasked512,
+ ssa.OpAMD64VPROLVDMasked512load,
ssa.OpAMD64VPROLVQMasked128,
+ ssa.OpAMD64VPROLVQMasked128load,
ssa.OpAMD64VPROLVQMasked256,
+ ssa.OpAMD64VPROLVQMasked256load,
ssa.OpAMD64VPROLVQMasked512,
+ ssa.OpAMD64VPROLVQMasked512load,
ssa.OpAMD64VPRORVDMasked128,
+ ssa.OpAMD64VPRORVDMasked128load,
ssa.OpAMD64VPRORVDMasked256,
+ ssa.OpAMD64VPRORVDMasked256load,
ssa.OpAMD64VPRORVDMasked512,
+ ssa.OpAMD64VPRORVDMasked512load,
ssa.OpAMD64VPRORVQMasked128,
+ ssa.OpAMD64VPRORVQMasked128load,
ssa.OpAMD64VPRORVQMasked256,
+ ssa.OpAMD64VPRORVQMasked256load,
ssa.OpAMD64VPRORVQMasked512,
+ ssa.OpAMD64VPRORVQMasked512load,
ssa.OpAMD64VSCALEFPSMasked128,
+ ssa.OpAMD64VSCALEFPSMasked128load,
ssa.OpAMD64VSCALEFPSMasked256,
+ ssa.OpAMD64VSCALEFPSMasked256load,
ssa.OpAMD64VSCALEFPSMasked512,
+ ssa.OpAMD64VSCALEFPSMasked512load,
ssa.OpAMD64VSCALEFPDMasked128,
+ ssa.OpAMD64VSCALEFPDMasked128load,
ssa.OpAMD64VSCALEFPDMasked256,
+ ssa.OpAMD64VSCALEFPDMasked256load,
ssa.OpAMD64VSCALEFPDMasked512,
+ ssa.OpAMD64VSCALEFPDMasked512load,
ssa.OpAMD64VPSHLDWMasked128,
ssa.OpAMD64VPSHLDWMasked256,
ssa.OpAMD64VPSHLDWMasked512,
ssa.OpAMD64VPSHLDDMasked128,
+ ssa.OpAMD64VPSHLDDMasked128load,
ssa.OpAMD64VPSHLDDMasked256,
+ ssa.OpAMD64VPSHLDDMasked256load,
ssa.OpAMD64VPSHLDDMasked512,
+ ssa.OpAMD64VPSHLDDMasked512load,
ssa.OpAMD64VPSHLDQMasked128,
+ ssa.OpAMD64VPSHLDQMasked128load,
ssa.OpAMD64VPSHLDQMasked256,
+ ssa.OpAMD64VPSHLDQMasked256load,
ssa.OpAMD64VPSHLDQMasked512,
+ ssa.OpAMD64VPSHLDQMasked512load,
ssa.OpAMD64VPSLLWMasked128,
ssa.OpAMD64VPSLLWMasked256,
ssa.OpAMD64VPSLLWMasked512,
ssa.OpAMD64VPSHRDWMasked256,
ssa.OpAMD64VPSHRDWMasked512,
ssa.OpAMD64VPSHRDDMasked128,
+ ssa.OpAMD64VPSHRDDMasked128load,
ssa.OpAMD64VPSHRDDMasked256,
+ ssa.OpAMD64VPSHRDDMasked256load,
ssa.OpAMD64VPSHRDDMasked512,
+ ssa.OpAMD64VPSHRDDMasked512load,
ssa.OpAMD64VPSHRDQMasked128,
+ ssa.OpAMD64VPSHRDQMasked128load,
ssa.OpAMD64VPSHRDQMasked256,
+ ssa.OpAMD64VPSHRDQMasked256load,
ssa.OpAMD64VPSHRDQMasked512,
+ ssa.OpAMD64VPSHRDQMasked512load,
ssa.OpAMD64VPSRAWMasked128,
ssa.OpAMD64VPSRAWMasked256,
ssa.OpAMD64VPSRAWMasked512,
ssa.OpAMD64VPSHLDVWMasked256,
ssa.OpAMD64VPSHLDVWMasked512,
ssa.OpAMD64VPSHLDVDMasked128,
+ ssa.OpAMD64VPSHLDVDMasked128load,
ssa.OpAMD64VPSHLDVDMasked256,
+ ssa.OpAMD64VPSHLDVDMasked256load,
ssa.OpAMD64VPSHLDVDMasked512,
+ ssa.OpAMD64VPSHLDVDMasked512load,
ssa.OpAMD64VPSHLDVQMasked128,
+ ssa.OpAMD64VPSHLDVQMasked128load,
ssa.OpAMD64VPSHLDVQMasked256,
+ ssa.OpAMD64VPSHLDVQMasked256load,
ssa.OpAMD64VPSHLDVQMasked512,
+ ssa.OpAMD64VPSHLDVQMasked512load,
ssa.OpAMD64VPSLLVWMasked128,
ssa.OpAMD64VPSLLVWMasked256,
ssa.OpAMD64VPSLLVWMasked512,
ssa.OpAMD64VPSLLVDMasked128,
+ ssa.OpAMD64VPSLLVDMasked128load,
ssa.OpAMD64VPSLLVDMasked256,
+ ssa.OpAMD64VPSLLVDMasked256load,
ssa.OpAMD64VPSLLVDMasked512,
+ ssa.OpAMD64VPSLLVDMasked512load,
ssa.OpAMD64VPSLLVQMasked128,
+ ssa.OpAMD64VPSLLVQMasked128load,
ssa.OpAMD64VPSLLVQMasked256,
+ ssa.OpAMD64VPSLLVQMasked256load,
ssa.OpAMD64VPSLLVQMasked512,
+ ssa.OpAMD64VPSLLVQMasked512load,
ssa.OpAMD64VPSHRDVWMasked128,
ssa.OpAMD64VPSHRDVWMasked256,
ssa.OpAMD64VPSHRDVWMasked512,
ssa.OpAMD64VPSHRDVDMasked128,
+ ssa.OpAMD64VPSHRDVDMasked128load,
ssa.OpAMD64VPSHRDVDMasked256,
+ ssa.OpAMD64VPSHRDVDMasked256load,
ssa.OpAMD64VPSHRDVDMasked512,
+ ssa.OpAMD64VPSHRDVDMasked512load,
ssa.OpAMD64VPSHRDVQMasked128,
+ ssa.OpAMD64VPSHRDVQMasked128load,
ssa.OpAMD64VPSHRDVQMasked256,
+ ssa.OpAMD64VPSHRDVQMasked256load,
ssa.OpAMD64VPSHRDVQMasked512,
+ ssa.OpAMD64VPSHRDVQMasked512load,
ssa.OpAMD64VPSRAVWMasked128,
ssa.OpAMD64VPSRAVWMasked256,
ssa.OpAMD64VPSRAVWMasked512,
ssa.OpAMD64VPSRAVDMasked128,
+ ssa.OpAMD64VPSRAVDMasked128load,
ssa.OpAMD64VPSRAVDMasked256,
+ ssa.OpAMD64VPSRAVDMasked256load,
ssa.OpAMD64VPSRAVDMasked512,
+ ssa.OpAMD64VPSRAVDMasked512load,
ssa.OpAMD64VPSRAVQMasked128,
+ ssa.OpAMD64VPSRAVQMasked128load,
ssa.OpAMD64VPSRAVQMasked256,
+ ssa.OpAMD64VPSRAVQMasked256load,
ssa.OpAMD64VPSRAVQMasked512,
+ ssa.OpAMD64VPSRAVQMasked512load,
ssa.OpAMD64VPSRLVWMasked128,
ssa.OpAMD64VPSRLVWMasked256,
ssa.OpAMD64VPSRLVWMasked512,
ssa.OpAMD64VPSRLVDMasked128,
+ ssa.OpAMD64VPSRLVDMasked128load,
ssa.OpAMD64VPSRLVDMasked256,
+ ssa.OpAMD64VPSRLVDMasked256load,
ssa.OpAMD64VPSRLVDMasked512,
+ ssa.OpAMD64VPSRLVDMasked512load,
ssa.OpAMD64VPSRLVQMasked128,
+ ssa.OpAMD64VPSRLVQMasked128load,
ssa.OpAMD64VPSRLVQMasked256,
+ ssa.OpAMD64VPSRLVQMasked256load,
ssa.OpAMD64VPSRLVQMasked512,
+ ssa.OpAMD64VPSRLVQMasked512load,
ssa.OpAMD64VSQRTPSMasked128,
+ ssa.OpAMD64VSQRTPSMasked128load,
ssa.OpAMD64VSQRTPSMasked256,
+ ssa.OpAMD64VSQRTPSMasked256load,
ssa.OpAMD64VSQRTPSMasked512,
+ ssa.OpAMD64VSQRTPSMasked512load,
ssa.OpAMD64VSQRTPDMasked128,
+ ssa.OpAMD64VSQRTPDMasked128load,
ssa.OpAMD64VSQRTPDMasked256,
+ ssa.OpAMD64VSQRTPDMasked256load,
ssa.OpAMD64VSQRTPDMasked512,
+ ssa.OpAMD64VSQRTPDMasked512load,
ssa.OpAMD64VSUBPSMasked128,
+ ssa.OpAMD64VSUBPSMasked128load,
ssa.OpAMD64VSUBPSMasked256,
+ ssa.OpAMD64VSUBPSMasked256load,
ssa.OpAMD64VSUBPSMasked512,
+ ssa.OpAMD64VSUBPSMasked512load,
ssa.OpAMD64VSUBPDMasked128,
+ ssa.OpAMD64VSUBPDMasked128load,
ssa.OpAMD64VSUBPDMasked256,
+ ssa.OpAMD64VSUBPDMasked256load,
ssa.OpAMD64VSUBPDMasked512,
+ ssa.OpAMD64VSUBPDMasked512load,
ssa.OpAMD64VPSUBBMasked128,
ssa.OpAMD64VPSUBBMasked256,
ssa.OpAMD64VPSUBBMasked512,
ssa.OpAMD64VPSUBWMasked256,
ssa.OpAMD64VPSUBWMasked512,
ssa.OpAMD64VPSUBDMasked128,
+ ssa.OpAMD64VPSUBDMasked128load,
ssa.OpAMD64VPSUBDMasked256,
+ ssa.OpAMD64VPSUBDMasked256load,
ssa.OpAMD64VPSUBDMasked512,
+ ssa.OpAMD64VPSUBDMasked512load,
ssa.OpAMD64VPSUBQMasked128,
+ ssa.OpAMD64VPSUBQMasked128load,
ssa.OpAMD64VPSUBQMasked256,
+ ssa.OpAMD64VPSUBQMasked256load,
ssa.OpAMD64VPSUBQMasked512,
+ ssa.OpAMD64VPSUBQMasked512load,
ssa.OpAMD64VPSUBSBMasked128,
ssa.OpAMD64VPSUBSBMasked256,
ssa.OpAMD64VPSUBSBMasked512,
ssa.OpAMD64VPSUBUSWMasked256,
ssa.OpAMD64VPSUBUSWMasked512,
ssa.OpAMD64VPXORDMasked128,
+ ssa.OpAMD64VPXORDMasked128load,
ssa.OpAMD64VPXORDMasked256,
+ ssa.OpAMD64VPXORDMasked256load,
ssa.OpAMD64VPXORDMasked512,
+ ssa.OpAMD64VPXORDMasked512load,
ssa.OpAMD64VPXORQMasked128,
+ ssa.OpAMD64VPXORQMasked128load,
ssa.OpAMD64VPXORQMasked256,
+ ssa.OpAMD64VPXORQMasked256load,
ssa.OpAMD64VPXORQMasked512,
+ ssa.OpAMD64VPXORQMasked512load,
ssa.OpAMD64VMOVUPSMasked128,
ssa.OpAMD64VMOVUPSMasked256,
ssa.OpAMD64VMOVUPSMasked512,
ssa.OpAMD64VPSLLWMasked256const,
ssa.OpAMD64VPSLLWMasked512const,
ssa.OpAMD64VPSLLDMasked128const,
+ ssa.OpAMD64VPSLLDMasked128constload,
ssa.OpAMD64VPSLLDMasked256const,
+ ssa.OpAMD64VPSLLDMasked256constload,
ssa.OpAMD64VPSLLDMasked512const,
+ ssa.OpAMD64VPSLLDMasked512constload,
ssa.OpAMD64VPSLLQMasked128const,
+ ssa.OpAMD64VPSLLQMasked128constload,
ssa.OpAMD64VPSLLQMasked256const,
+ ssa.OpAMD64VPSLLQMasked256constload,
ssa.OpAMD64VPSLLQMasked512const,
+ ssa.OpAMD64VPSLLQMasked512constload,
ssa.OpAMD64VPSRLWMasked128const,
ssa.OpAMD64VPSRLWMasked256const,
ssa.OpAMD64VPSRLWMasked512const,
ssa.OpAMD64VPSRLDMasked128const,
+ ssa.OpAMD64VPSRLDMasked128constload,
ssa.OpAMD64VPSRLDMasked256const,
+ ssa.OpAMD64VPSRLDMasked256constload,
ssa.OpAMD64VPSRLDMasked512const,
+ ssa.OpAMD64VPSRLDMasked512constload,
ssa.OpAMD64VPSRLQMasked128const,
+ ssa.OpAMD64VPSRLQMasked128constload,
ssa.OpAMD64VPSRLQMasked256const,
+ ssa.OpAMD64VPSRLQMasked256constload,
ssa.OpAMD64VPSRLQMasked512const,
+ ssa.OpAMD64VPSRLQMasked512constload,
ssa.OpAMD64VPSRAWMasked128const,
ssa.OpAMD64VPSRAWMasked256const,
ssa.OpAMD64VPSRAWMasked512const,
ssa.OpAMD64VPSRADMasked128const,
+ ssa.OpAMD64VPSRADMasked128constload,
ssa.OpAMD64VPSRADMasked256const,
+ ssa.OpAMD64VPSRADMasked256constload,
ssa.OpAMD64VPSRADMasked512const,
+ ssa.OpAMD64VPSRADMasked512constload,
ssa.OpAMD64VPSRAQMasked128const,
+ ssa.OpAMD64VPSRAQMasked128constload,
ssa.OpAMD64VPSRAQMasked256const,
- ssa.OpAMD64VPSRAQMasked512const:
+ ssa.OpAMD64VPSRAQMasked256constload,
+ ssa.OpAMD64VPSRAQMasked512const,
+ ssa.OpAMD64VPSRAQMasked512constload:
x86.ParseSuffix(p, "Z")
}
(ternUint64x2 ...) => (VPTERNLOGQ128 ...)
(ternUint64x4 ...) => (VPTERNLOGQ256 ...)
(ternUint64x8 ...) => (VPTERNLOGQ512 ...)
+(VMOVDQU8Masked128 (VPABSB128 x) mask) => (VPABSBMasked128 x mask)
+(VMOVDQU8Masked256 (VPABSB256 x) mask) => (VPABSBMasked256 x mask)
(VMOVDQU8Masked512 (VPABSB512 x) mask) => (VPABSBMasked512 x mask)
+(VMOVDQU16Masked128 (VPABSW128 x) mask) => (VPABSWMasked128 x mask)
+(VMOVDQU16Masked256 (VPABSW256 x) mask) => (VPABSWMasked256 x mask)
(VMOVDQU16Masked512 (VPABSW512 x) mask) => (VPABSWMasked512 x mask)
+(VMOVDQU32Masked128 (VPABSD128 x) mask) => (VPABSDMasked128 x mask)
+(VMOVDQU32Masked256 (VPABSD256 x) mask) => (VPABSDMasked256 x mask)
(VMOVDQU32Masked512 (VPABSD512 x) mask) => (VPABSDMasked512 x mask)
+(VMOVDQU64Masked128 (VPABSQ128 x) mask) => (VPABSQMasked128 x mask)
+(VMOVDQU64Masked256 (VPABSQ256 x) mask) => (VPABSQMasked256 x mask)
(VMOVDQU64Masked512 (VPABSQ512 x) mask) => (VPABSQMasked512 x mask)
-(VMOVDQU32Masked512 (VPDPWSSD512 x y z) mask) => (VPDPWSSDMasked512 x y z mask)
+(VMOVDQU32Masked128 (VPDPBUSD128 x y z) mask) => (VPDPBUSDMasked128 x y z mask)
+(VMOVDQU32Masked256 (VPDPBUSD256 x y z) mask) => (VPDPBUSDMasked256 x y z mask)
(VMOVDQU32Masked512 (VPDPBUSD512 x y z) mask) => (VPDPBUSDMasked512 x y z mask)
+(VMOVDQU32Masked128 (VPDPBUSDS128 x y z) mask) => (VPDPBUSDSMasked128 x y z mask)
+(VMOVDQU32Masked256 (VPDPBUSDS256 x y z) mask) => (VPDPBUSDSMasked256 x y z mask)
(VMOVDQU32Masked512 (VPDPBUSDS512 x y z) mask) => (VPDPBUSDSMasked512 x y z mask)
+(VMOVDQU32Masked128 (VADDPS128 x y) mask) => (VADDPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VADDPS256 x y) mask) => (VADDPSMasked256 x y mask)
(VMOVDQU32Masked512 (VADDPS512 x y) mask) => (VADDPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VADDPD128 x y) mask) => (VADDPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VADDPD256 x y) mask) => (VADDPDMasked256 x y mask)
(VMOVDQU64Masked512 (VADDPD512 x y) mask) => (VADDPDMasked512 x y mask)
+(VMOVDQU8Masked128 (VPADDB128 x y) mask) => (VPADDBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPADDB256 x y) mask) => (VPADDBMasked256 x y mask)
(VMOVDQU8Masked512 (VPADDB512 x y) mask) => (VPADDBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPADDW128 x y) mask) => (VPADDWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPADDW256 x y) mask) => (VPADDWMasked256 x y mask)
(VMOVDQU16Masked512 (VPADDW512 x y) mask) => (VPADDWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPADDD128 x y) mask) => (VPADDDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPADDD256 x y) mask) => (VPADDDMasked256 x y mask)
(VMOVDQU32Masked512 (VPADDD512 x y) mask) => (VPADDDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPADDQ128 x y) mask) => (VPADDQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPADDQ256 x y) mask) => (VPADDQMasked256 x y mask)
(VMOVDQU64Masked512 (VPADDQ512 x y) mask) => (VPADDQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPADDSB128 x y) mask) => (VPADDSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPADDSB256 x y) mask) => (VPADDSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPADDSB512 x y) mask) => (VPADDSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPADDSW128 x y) mask) => (VPADDSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPADDSW256 x y) mask) => (VPADDSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPADDSW512 x y) mask) => (VPADDSWMasked512 x y mask)
+(VMOVDQU8Masked128 (VPADDUSB128 x y) mask) => (VPADDUSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPADDUSB256 x y) mask) => (VPADDUSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPADDUSB512 x y) mask) => (VPADDUSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPADDUSW128 x y) mask) => (VPADDUSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPADDUSW256 x y) mask) => (VPADDUSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPADDUSW512 x y) mask) => (VPADDUSWMasked512 x y mask)
(VMOVDQU32Masked512 (VPANDD512 x y) mask) => (VPANDDMasked512 x y mask)
(VMOVDQU64Masked512 (VPANDQ512 x y) mask) => (VPANDQMasked512 x y mask)
(VMOVDQU32Masked512 (VPANDND512 x y) mask) => (VPANDNDMasked512 x y mask)
(VMOVDQU64Masked512 (VPANDNQ512 x y) mask) => (VPANDNQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPAVGB128 x y) mask) => (VPAVGBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPAVGB256 x y) mask) => (VPAVGBMasked256 x y mask)
(VMOVDQU8Masked512 (VPAVGB512 x y) mask) => (VPAVGBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPAVGW128 x y) mask) => (VPAVGWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPAVGW256 x y) mask) => (VPAVGWMasked256 x y mask)
(VMOVDQU16Masked512 (VPAVGW512 x y) mask) => (VPAVGWMasked512 x y mask)
+(VMOVDQU32Masked128 (VBROADCASTSS128 x) mask) => (VBROADCASTSSMasked128 x mask)
+(VMOVDQU64Masked128 (VPBROADCASTQ128 x) mask) => (VPBROADCASTQMasked128 x mask)
+(VMOVDQU8Masked128 (VPBROADCASTB128 x) mask) => (VPBROADCASTBMasked128 x mask)
+(VMOVDQU16Masked128 (VPBROADCASTW128 x) mask) => (VPBROADCASTWMasked128 x mask)
+(VMOVDQU32Masked128 (VPBROADCASTD128 x) mask) => (VPBROADCASTDMasked128 x mask)
+(VMOVDQU32Masked256 (VBROADCASTSS256 x) mask) => (VBROADCASTSSMasked256 x mask)
+(VMOVDQU64Masked256 (VBROADCASTSD256 x) mask) => (VBROADCASTSDMasked256 x mask)
+(VMOVDQU8Masked256 (VPBROADCASTB256 x) mask) => (VPBROADCASTBMasked256 x mask)
+(VMOVDQU16Masked256 (VPBROADCASTW256 x) mask) => (VPBROADCASTWMasked256 x mask)
+(VMOVDQU32Masked256 (VPBROADCASTD256 x) mask) => (VPBROADCASTDMasked256 x mask)
+(VMOVDQU64Masked256 (VPBROADCASTQ256 x) mask) => (VPBROADCASTQMasked256 x mask)
(VMOVDQU32Masked512 (VBROADCASTSS512 x) mask) => (VBROADCASTSSMasked512 x mask)
(VMOVDQU64Masked512 (VBROADCASTSD512 x) mask) => (VBROADCASTSDMasked512 x mask)
(VMOVDQU8Masked512 (VPBROADCASTB512 x) mask) => (VPBROADCASTBMasked512 x mask)
(VMOVDQU16Masked512 (VPBROADCASTW512 x) mask) => (VPBROADCASTWMasked512 x mask)
(VMOVDQU32Masked512 (VPBROADCASTD512 x) mask) => (VPBROADCASTDMasked512 x mask)
(VMOVDQU64Masked512 (VPBROADCASTQ512 x) mask) => (VPBROADCASTQMasked512 x mask)
+(VMOVDQU32Masked128 (VRNDSCALEPS128 [a] x) mask) => (VRNDSCALEPSMasked128 [a] x mask)
+(VMOVDQU32Masked256 (VRNDSCALEPS256 [a] x) mask) => (VRNDSCALEPSMasked256 [a] x mask)
(VMOVDQU32Masked512 (VRNDSCALEPS512 [a] x) mask) => (VRNDSCALEPSMasked512 [a] x mask)
+(VMOVDQU64Masked128 (VRNDSCALEPD128 [a] x) mask) => (VRNDSCALEPDMasked128 [a] x mask)
+(VMOVDQU64Masked256 (VRNDSCALEPD256 [a] x) mask) => (VRNDSCALEPDMasked256 [a] x mask)
(VMOVDQU64Masked512 (VRNDSCALEPD512 [a] x) mask) => (VRNDSCALEPDMasked512 [a] x mask)
+(VMOVDQU32Masked128 (VREDUCEPS128 [a] x) mask) => (VREDUCEPSMasked128 [a] x mask)
+(VMOVDQU32Masked256 (VREDUCEPS256 [a] x) mask) => (VREDUCEPSMasked256 [a] x mask)
(VMOVDQU32Masked512 (VREDUCEPS512 [a] x) mask) => (VREDUCEPSMasked512 [a] x mask)
+(VMOVDQU64Masked128 (VREDUCEPD128 [a] x) mask) => (VREDUCEPDMasked128 [a] x mask)
+(VMOVDQU64Masked256 (VREDUCEPD256 [a] x) mask) => (VREDUCEPDMasked256 [a] x mask)
(VMOVDQU64Masked512 (VREDUCEPD512 [a] x) mask) => (VREDUCEPDMasked512 [a] x mask)
+(VMOVDQU16Masked128 (VPMOVWB128 x) mask) => (VPMOVWBMasked128 x mask)
+(VMOVDQU16Masked256 (VPMOVWB256 x) mask) => (VPMOVWBMasked256 x mask)
+(VMOVDQU32Masked128 (VPMOVDB128 x) mask) => (VPMOVDBMasked128 x mask)
+(VMOVDQU64Masked128 (VPMOVQB128 x) mask) => (VPMOVQBMasked128 x mask)
+(VMOVDQU16Masked128 (VPMOVSWB128 x) mask) => (VPMOVSWBMasked128 x mask)
+(VMOVDQU16Masked256 (VPMOVSWB256 x) mask) => (VPMOVSWBMasked256 x mask)
+(VMOVDQU32Masked128 (VPMOVSDB128 x) mask) => (VPMOVSDBMasked128 x mask)
+(VMOVDQU64Masked128 (VPMOVSQB128 x) mask) => (VPMOVSQBMasked128 x mask)
+(VMOVDQU8Masked256 (VPMOVSXBW256 x) mask) => (VPMOVSXBWMasked256 x mask)
(VMOVDQU8Masked512 (VPMOVSXBW512 x) mask) => (VPMOVSXBWMasked512 x mask)
+(VMOVDQU32Masked128 (VPMOVDW128 x) mask) => (VPMOVDWMasked128 x mask)
+(VMOVDQU32Masked256 (VPMOVDW256 x) mask) => (VPMOVDWMasked256 x mask)
+(VMOVDQU64Masked128 (VPMOVQW128 x) mask) => (VPMOVQWMasked128 x mask)
+(VMOVDQU32Masked128 (VPMOVSDW128 x) mask) => (VPMOVSDWMasked128 x mask)
+(VMOVDQU32Masked256 (VPMOVSDW256 x) mask) => (VPMOVSDWMasked256 x mask)
+(VMOVDQU64Masked128 (VPMOVSQW128 x) mask) => (VPMOVSQWMasked128 x mask)
+(VMOVDQU32Masked128 (VPACKSSDW128 x y) mask) => (VPACKSSDWMasked128 x y mask)
+(VMOVDQU32Masked256 (VPACKSSDW256 x y) mask) => (VPACKSSDWMasked256 x y mask)
(VMOVDQU32Masked512 (VPACKSSDW512 x y) mask) => (VPACKSSDWMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMOVSXBW128 x) mask) => (VPMOVSXBWMasked128 x mask)
+(VMOVDQU32Masked128 (VCVTTPS2DQ128 x) mask) => (VCVTTPS2DQMasked128 x mask)
+(VMOVDQU32Masked256 (VCVTTPS2DQ256 x) mask) => (VCVTTPS2DQMasked256 x mask)
(VMOVDQU32Masked512 (VCVTTPS2DQ512 x) mask) => (VCVTTPS2DQMasked512 x mask)
(VMOVDQU8Masked512 (VPMOVSXBD512 x) mask) => (VPMOVSXBDMasked512 x mask)
+(VMOVDQU16Masked256 (VPMOVSXWD256 x) mask) => (VPMOVSXWDMasked256 x mask)
(VMOVDQU16Masked512 (VPMOVSXWD512 x) mask) => (VPMOVSXWDMasked512 x mask)
+(VMOVDQU64Masked128 (VPMOVQD128 x) mask) => (VPMOVQDMasked128 x mask)
+(VMOVDQU64Masked256 (VPMOVQD256 x) mask) => (VPMOVQDMasked256 x mask)
+(VMOVDQU64Masked128 (VPMOVSQD128 x) mask) => (VPMOVSQDMasked128 x mask)
+(VMOVDQU64Masked256 (VPMOVSQD256 x) mask) => (VPMOVSQDMasked256 x mask)
+(VMOVDQU8Masked128 (VPMOVSXBD128 x) mask) => (VPMOVSXBDMasked128 x mask)
+(VMOVDQU16Masked128 (VPMOVSXWD128 x) mask) => (VPMOVSXWDMasked128 x mask)
+(VMOVDQU8Masked256 (VPMOVSXBD256 x) mask) => (VPMOVSXBDMasked256 x mask)
(VMOVDQU16Masked512 (VPMOVSXWQ512 x) mask) => (VPMOVSXWQMasked512 x mask)
+(VMOVDQU32Masked256 (VPMOVSXDQ256 x) mask) => (VPMOVSXDQMasked256 x mask)
(VMOVDQU32Masked512 (VPMOVSXDQ512 x) mask) => (VPMOVSXDQMasked512 x mask)
+(VMOVDQU8Masked128 (VPMOVSXBQ128 x) mask) => (VPMOVSXBQMasked128 x mask)
+(VMOVDQU16Masked128 (VPMOVSXWQ128 x) mask) => (VPMOVSXWQMasked128 x mask)
+(VMOVDQU32Masked128 (VPMOVSXDQ128 x) mask) => (VPMOVSXDQMasked128 x mask)
+(VMOVDQU8Masked256 (VPMOVSXBQ256 x) mask) => (VPMOVSXBQMasked256 x mask)
(VMOVDQU8Masked512 (VPMOVSXBQ512 x) mask) => (VPMOVSXBQMasked512 x mask)
+(VMOVDQU16Masked128 (VPMOVUSWB128 x) mask) => (VPMOVUSWBMasked128 x mask)
+(VMOVDQU16Masked256 (VPMOVUSWB256 x) mask) => (VPMOVUSWBMasked256 x mask)
+(VMOVDQU32Masked128 (VPMOVUSDB128 x) mask) => (VPMOVUSDBMasked128 x mask)
+(VMOVDQU64Masked128 (VPMOVUSQB128 x) mask) => (VPMOVUSQBMasked128 x mask)
+(VMOVDQU8Masked256 (VPMOVZXBW256 x) mask) => (VPMOVZXBWMasked256 x mask)
(VMOVDQU8Masked512 (VPMOVZXBW512 x) mask) => (VPMOVZXBWMasked512 x mask)
+(VMOVDQU32Masked128 (VPMOVUSDW128 x) mask) => (VPMOVUSDWMasked128 x mask)
+(VMOVDQU32Masked256 (VPMOVUSDW256 x) mask) => (VPMOVUSDWMasked256 x mask)
+(VMOVDQU64Masked128 (VPMOVUSQW128 x) mask) => (VPMOVUSQWMasked128 x mask)
+(VMOVDQU32Masked128 (VPACKUSDW128 x y) mask) => (VPACKUSDWMasked128 x y mask)
+(VMOVDQU32Masked256 (VPACKUSDW256 x y) mask) => (VPACKUSDWMasked256 x y mask)
(VMOVDQU32Masked512 (VPACKUSDW512 x y) mask) => (VPACKUSDWMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMOVZXBW128 x) mask) => (VPMOVZXBWMasked128 x mask)
+(VMOVDQU32Masked128 (VCVTPS2UDQ128 x) mask) => (VCVTPS2UDQMasked128 x mask)
+(VMOVDQU32Masked256 (VCVTPS2UDQ256 x) mask) => (VCVTPS2UDQMasked256 x mask)
(VMOVDQU32Masked512 (VCVTPS2UDQ512 x) mask) => (VCVTPS2UDQMasked512 x mask)
(VMOVDQU8Masked512 (VPMOVZXBD512 x) mask) => (VPMOVZXBDMasked512 x mask)
+(VMOVDQU16Masked256 (VPMOVZXWD256 x) mask) => (VPMOVZXWDMasked256 x mask)
(VMOVDQU16Masked512 (VPMOVZXWD512 x) mask) => (VPMOVZXWDMasked512 x mask)
+(VMOVDQU64Masked128 (VPMOVUSQD128 x) mask) => (VPMOVUSQDMasked128 x mask)
+(VMOVDQU64Masked256 (VPMOVUSQD256 x) mask) => (VPMOVUSQDMasked256 x mask)
+(VMOVDQU8Masked128 (VPMOVZXBD128 x) mask) => (VPMOVZXBDMasked128 x mask)
+(VMOVDQU16Masked128 (VPMOVZXWD128 x) mask) => (VPMOVZXWDMasked128 x mask)
+(VMOVDQU8Masked256 (VPMOVZXBD256 x) mask) => (VPMOVZXBDMasked256 x mask)
(VMOVDQU16Masked512 (VPMOVZXWQ512 x) mask) => (VPMOVZXWQMasked512 x mask)
+(VMOVDQU32Masked256 (VPMOVZXDQ256 x) mask) => (VPMOVZXDQMasked256 x mask)
(VMOVDQU32Masked512 (VPMOVZXDQ512 x) mask) => (VPMOVZXDQMasked512 x mask)
+(VMOVDQU8Masked128 (VPMOVZXBQ128 x) mask) => (VPMOVZXBQMasked128 x mask)
+(VMOVDQU16Masked128 (VPMOVZXWQ128 x) mask) => (VPMOVZXWQMasked128 x mask)
+(VMOVDQU32Masked128 (VPMOVZXDQ128 x) mask) => (VPMOVZXDQMasked128 x mask)
+(VMOVDQU16Masked256 (VPMOVSXWQ256 x) mask) => (VPMOVSXWQMasked256 x mask)
+(VMOVDQU8Masked256 (VPMOVZXBQ256 x) mask) => (VPMOVZXBQMasked256 x mask)
+(VMOVDQU16Masked256 (VPMOVZXWQ256 x) mask) => (VPMOVZXWQMasked256 x mask)
(VMOVDQU8Masked512 (VPMOVZXBQ512 x) mask) => (VPMOVZXBQMasked512 x mask)
+(VMOVDQU32Masked128 (VDIVPS128 x y) mask) => (VDIVPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VDIVPS256 x y) mask) => (VDIVPSMasked256 x y mask)
(VMOVDQU32Masked512 (VDIVPS512 x y) mask) => (VDIVPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VDIVPD128 x y) mask) => (VDIVPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VDIVPD256 x y) mask) => (VDIVPDMasked256 x y mask)
(VMOVDQU64Masked512 (VDIVPD512 x y) mask) => (VDIVPDMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMADDWD128 x y) mask) => (VPMADDWDMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMADDWD256 x y) mask) => (VPMADDWDMasked256 x y mask)
(VMOVDQU16Masked512 (VPMADDWD512 x y) mask) => (VPMADDWDMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMADDUBSW128 x y) mask) => (VPMADDUBSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMADDUBSW256 x y) mask) => (VPMADDUBSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMADDUBSW512 x y) mask) => (VPMADDUBSWMasked512 x y mask)
+(VMOVDQU8Masked128 (VGF2P8AFFINEINVQB128 [a] x y) mask) => (VGF2P8AFFINEINVQBMasked128 [a] x y mask)
+(VMOVDQU8Masked256 (VGF2P8AFFINEINVQB256 [a] x y) mask) => (VGF2P8AFFINEINVQBMasked256 [a] x y mask)
(VMOVDQU8Masked512 (VGF2P8AFFINEINVQB512 [a] x y) mask) => (VGF2P8AFFINEINVQBMasked512 [a] x y mask)
+(VMOVDQU8Masked128 (VGF2P8AFFINEQB128 [a] x y) mask) => (VGF2P8AFFINEQBMasked128 [a] x y mask)
+(VMOVDQU8Masked256 (VGF2P8AFFINEQB256 [a] x y) mask) => (VGF2P8AFFINEQBMasked256 [a] x y mask)
(VMOVDQU8Masked512 (VGF2P8AFFINEQB512 [a] x y) mask) => (VGF2P8AFFINEQBMasked512 [a] x y mask)
+(VMOVDQU8Masked128 (VGF2P8MULB128 x y) mask) => (VGF2P8MULBMasked128 x y mask)
+(VMOVDQU8Masked256 (VGF2P8MULB256 x y) mask) => (VGF2P8MULBMasked256 x y mask)
(VMOVDQU8Masked512 (VGF2P8MULB512 x y) mask) => (VGF2P8MULBMasked512 x y mask)
+(VMOVDQU32Masked128 (VPLZCNTD128 x) mask) => (VPLZCNTDMasked128 x mask)
+(VMOVDQU32Masked256 (VPLZCNTD256 x) mask) => (VPLZCNTDMasked256 x mask)
(VMOVDQU32Masked512 (VPLZCNTD512 x) mask) => (VPLZCNTDMasked512 x mask)
+(VMOVDQU64Masked128 (VPLZCNTQ128 x) mask) => (VPLZCNTQMasked128 x mask)
+(VMOVDQU64Masked256 (VPLZCNTQ256 x) mask) => (VPLZCNTQMasked256 x mask)
(VMOVDQU64Masked512 (VPLZCNTQ512 x) mask) => (VPLZCNTQMasked512 x mask)
+(VMOVDQU32Masked128 (VMAXPS128 x y) mask) => (VMAXPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VMAXPS256 x y) mask) => (VMAXPSMasked256 x y mask)
(VMOVDQU32Masked512 (VMAXPS512 x y) mask) => (VMAXPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VMAXPD128 x y) mask) => (VMAXPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VMAXPD256 x y) mask) => (VMAXPDMasked256 x y mask)
(VMOVDQU64Masked512 (VMAXPD512 x y) mask) => (VMAXPDMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMAXSB128 x y) mask) => (VPMAXSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPMAXSB256 x y) mask) => (VPMAXSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPMAXSB512 x y) mask) => (VPMAXSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMAXSW128 x y) mask) => (VPMAXSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMAXSW256 x y) mask) => (VPMAXSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMAXSW512 x y) mask) => (VPMAXSWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPMAXSD128 x y) mask) => (VPMAXSDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPMAXSD256 x y) mask) => (VPMAXSDMasked256 x y mask)
(VMOVDQU32Masked512 (VPMAXSD512 x y) mask) => (VPMAXSDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPMAXSQ128 x y) mask) => (VPMAXSQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPMAXSQ256 x y) mask) => (VPMAXSQMasked256 x y mask)
(VMOVDQU64Masked512 (VPMAXSQ512 x y) mask) => (VPMAXSQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMAXUB128 x y) mask) => (VPMAXUBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPMAXUB256 x y) mask) => (VPMAXUBMasked256 x y mask)
(VMOVDQU8Masked512 (VPMAXUB512 x y) mask) => (VPMAXUBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMAXUW128 x y) mask) => (VPMAXUWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMAXUW256 x y) mask) => (VPMAXUWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMAXUW512 x y) mask) => (VPMAXUWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPMAXUD128 x y) mask) => (VPMAXUDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPMAXUD256 x y) mask) => (VPMAXUDMasked256 x y mask)
(VMOVDQU32Masked512 (VPMAXUD512 x y) mask) => (VPMAXUDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPMAXUQ128 x y) mask) => (VPMAXUQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPMAXUQ256 x y) mask) => (VPMAXUQMasked256 x y mask)
(VMOVDQU64Masked512 (VPMAXUQ512 x y) mask) => (VPMAXUQMasked512 x y mask)
+(VMOVDQU32Masked128 (VMINPS128 x y) mask) => (VMINPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VMINPS256 x y) mask) => (VMINPSMasked256 x y mask)
(VMOVDQU32Masked512 (VMINPS512 x y) mask) => (VMINPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VMINPD128 x y) mask) => (VMINPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VMINPD256 x y) mask) => (VMINPDMasked256 x y mask)
(VMOVDQU64Masked512 (VMINPD512 x y) mask) => (VMINPDMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMINSB128 x y) mask) => (VPMINSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPMINSB256 x y) mask) => (VPMINSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPMINSB512 x y) mask) => (VPMINSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMINSW128 x y) mask) => (VPMINSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMINSW256 x y) mask) => (VPMINSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMINSW512 x y) mask) => (VPMINSWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPMINSD128 x y) mask) => (VPMINSDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPMINSD256 x y) mask) => (VPMINSDMasked256 x y mask)
(VMOVDQU32Masked512 (VPMINSD512 x y) mask) => (VPMINSDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPMINSQ128 x y) mask) => (VPMINSQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPMINSQ256 x y) mask) => (VPMINSQMasked256 x y mask)
(VMOVDQU64Masked512 (VPMINSQ512 x y) mask) => (VPMINSQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPMINUB128 x y) mask) => (VPMINUBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPMINUB256 x y) mask) => (VPMINUBMasked256 x y mask)
(VMOVDQU8Masked512 (VPMINUB512 x y) mask) => (VPMINUBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMINUW128 x y) mask) => (VPMINUWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMINUW256 x y) mask) => (VPMINUWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMINUW512 x y) mask) => (VPMINUWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPMINUD128 x y) mask) => (VPMINUDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPMINUD256 x y) mask) => (VPMINUDMasked256 x y mask)
(VMOVDQU32Masked512 (VPMINUD512 x y) mask) => (VPMINUDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPMINUQ128 x y) mask) => (VPMINUQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPMINUQ256 x y) mask) => (VPMINUQMasked256 x y mask)
(VMOVDQU64Masked512 (VPMINUQ512 x y) mask) => (VPMINUQMasked512 x y mask)
+(VMOVDQU32Masked128 (VFMADD213PS128 x y z) mask) => (VFMADD213PSMasked128 x y z mask)
+(VMOVDQU32Masked256 (VFMADD213PS256 x y z) mask) => (VFMADD213PSMasked256 x y z mask)
(VMOVDQU32Masked512 (VFMADD213PS512 x y z) mask) => (VFMADD213PSMasked512 x y z mask)
+(VMOVDQU64Masked128 (VFMADD213PD128 x y z) mask) => (VFMADD213PDMasked128 x y z mask)
+(VMOVDQU64Masked256 (VFMADD213PD256 x y z) mask) => (VFMADD213PDMasked256 x y z mask)
(VMOVDQU64Masked512 (VFMADD213PD512 x y z) mask) => (VFMADD213PDMasked512 x y z mask)
+(VMOVDQU32Masked128 (VFMADDSUB213PS128 x y z) mask) => (VFMADDSUB213PSMasked128 x y z mask)
+(VMOVDQU32Masked256 (VFMADDSUB213PS256 x y z) mask) => (VFMADDSUB213PSMasked256 x y z mask)
(VMOVDQU32Masked512 (VFMADDSUB213PS512 x y z) mask) => (VFMADDSUB213PSMasked512 x y z mask)
+(VMOVDQU64Masked128 (VFMADDSUB213PD128 x y z) mask) => (VFMADDSUB213PDMasked128 x y z mask)
+(VMOVDQU64Masked256 (VFMADDSUB213PD256 x y z) mask) => (VFMADDSUB213PDMasked256 x y z mask)
(VMOVDQU64Masked512 (VFMADDSUB213PD512 x y z) mask) => (VFMADDSUB213PDMasked512 x y z mask)
+(VMOVDQU16Masked128 (VPMULHW128 x y) mask) => (VPMULHWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMULHW256 x y) mask) => (VPMULHWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMULHW512 x y) mask) => (VPMULHWMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMULHUW128 x y) mask) => (VPMULHUWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMULHUW256 x y) mask) => (VPMULHUWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMULHUW512 x y) mask) => (VPMULHUWMasked512 x y mask)
+(VMOVDQU32Masked128 (VMULPS128 x y) mask) => (VMULPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VMULPS256 x y) mask) => (VMULPSMasked256 x y mask)
(VMOVDQU32Masked512 (VMULPS512 x y) mask) => (VMULPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VMULPD128 x y) mask) => (VMULPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VMULPD256 x y) mask) => (VMULPDMasked256 x y mask)
(VMOVDQU64Masked512 (VMULPD512 x y) mask) => (VMULPDMasked512 x y mask)
+(VMOVDQU16Masked128 (VPMULLW128 x y) mask) => (VPMULLWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPMULLW256 x y) mask) => (VPMULLWMasked256 x y mask)
(VMOVDQU16Masked512 (VPMULLW512 x y) mask) => (VPMULLWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPMULLD128 x y) mask) => (VPMULLDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPMULLD256 x y) mask) => (VPMULLDMasked256 x y mask)
(VMOVDQU32Masked512 (VPMULLD512 x y) mask) => (VPMULLDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPMULLQ128 x y) mask) => (VPMULLQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPMULLQ256 x y) mask) => (VPMULLQMasked256 x y mask)
(VMOVDQU64Masked512 (VPMULLQ512 x y) mask) => (VPMULLQMasked512 x y mask)
+(VMOVDQU32Masked128 (VFMSUBADD213PS128 x y z) mask) => (VFMSUBADD213PSMasked128 x y z mask)
+(VMOVDQU32Masked256 (VFMSUBADD213PS256 x y z) mask) => (VFMSUBADD213PSMasked256 x y z mask)
(VMOVDQU32Masked512 (VFMSUBADD213PS512 x y z) mask) => (VFMSUBADD213PSMasked512 x y z mask)
+(VMOVDQU64Masked128 (VFMSUBADD213PD128 x y z) mask) => (VFMSUBADD213PDMasked128 x y z mask)
+(VMOVDQU64Masked256 (VFMSUBADD213PD256 x y z) mask) => (VFMSUBADD213PDMasked256 x y z mask)
(VMOVDQU64Masked512 (VFMSUBADD213PD512 x y z) mask) => (VFMSUBADD213PDMasked512 x y z mask)
+(VMOVDQU8Masked128 (VPOPCNTB128 x) mask) => (VPOPCNTBMasked128 x mask)
+(VMOVDQU8Masked256 (VPOPCNTB256 x) mask) => (VPOPCNTBMasked256 x mask)
(VMOVDQU8Masked512 (VPOPCNTB512 x) mask) => (VPOPCNTBMasked512 x mask)
+(VMOVDQU16Masked128 (VPOPCNTW128 x) mask) => (VPOPCNTWMasked128 x mask)
+(VMOVDQU16Masked256 (VPOPCNTW256 x) mask) => (VPOPCNTWMasked256 x mask)
(VMOVDQU16Masked512 (VPOPCNTW512 x) mask) => (VPOPCNTWMasked512 x mask)
+(VMOVDQU32Masked128 (VPOPCNTD128 x) mask) => (VPOPCNTDMasked128 x mask)
+(VMOVDQU32Masked256 (VPOPCNTD256 x) mask) => (VPOPCNTDMasked256 x mask)
(VMOVDQU32Masked512 (VPOPCNTD512 x) mask) => (VPOPCNTDMasked512 x mask)
+(VMOVDQU64Masked128 (VPOPCNTQ128 x) mask) => (VPOPCNTQMasked128 x mask)
+(VMOVDQU64Masked256 (VPOPCNTQ256 x) mask) => (VPOPCNTQMasked256 x mask)
(VMOVDQU64Masked512 (VPOPCNTQ512 x) mask) => (VPOPCNTQMasked512 x mask)
(VMOVDQU32Masked512 (VPORD512 x y) mask) => (VPORDMasked512 x y mask)
(VMOVDQU64Masked512 (VPORQ512 x y) mask) => (VPORQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPERMI2B128 x y z) mask) => (VPERMI2BMasked128 x y z mask)
+(VMOVDQU8Masked256 (VPERMI2B256 x y z) mask) => (VPERMI2BMasked256 x y z mask)
(VMOVDQU8Masked512 (VPERMI2B512 x y z) mask) => (VPERMI2BMasked512 x y z mask)
+(VMOVDQU16Masked128 (VPERMI2W128 x y z) mask) => (VPERMI2WMasked128 x y z mask)
+(VMOVDQU16Masked256 (VPERMI2W256 x y z) mask) => (VPERMI2WMasked256 x y z mask)
(VMOVDQU16Masked512 (VPERMI2W512 x y z) mask) => (VPERMI2WMasked512 x y z mask)
+(VMOVDQU32Masked128 (VPERMI2PS128 x y z) mask) => (VPERMI2PSMasked128 x y z mask)
+(VMOVDQU32Masked128 (VPERMI2D128 x y z) mask) => (VPERMI2DMasked128 x y z mask)
+(VMOVDQU32Masked256 (VPERMI2PS256 x y z) mask) => (VPERMI2PSMasked256 x y z mask)
+(VMOVDQU32Masked256 (VPERMI2D256 x y z) mask) => (VPERMI2DMasked256 x y z mask)
(VMOVDQU32Masked512 (VPERMI2PS512 x y z) mask) => (VPERMI2PSMasked512 x y z mask)
(VMOVDQU32Masked512 (VPERMI2D512 x y z) mask) => (VPERMI2DMasked512 x y z mask)
+(VMOVDQU64Masked128 (VPERMI2PD128 x y z) mask) => (VPERMI2PDMasked128 x y z mask)
+(VMOVDQU64Masked128 (VPERMI2Q128 x y z) mask) => (VPERMI2QMasked128 x y z mask)
+(VMOVDQU64Masked256 (VPERMI2PD256 x y z) mask) => (VPERMI2PDMasked256 x y z mask)
+(VMOVDQU64Masked256 (VPERMI2Q256 x y z) mask) => (VPERMI2QMasked256 x y z mask)
(VMOVDQU64Masked512 (VPERMI2PD512 x y z) mask) => (VPERMI2PDMasked512 x y z mask)
(VMOVDQU64Masked512 (VPERMI2Q512 x y z) mask) => (VPERMI2QMasked512 x y z mask)
+(VMOVDQU32Masked256 (VPSHUFD256 [a] x) mask) => (VPSHUFDMasked256 [a] x mask)
(VMOVDQU32Masked512 (VPSHUFD512 [a] x) mask) => (VPSHUFDMasked512 [a] x mask)
+(VMOVDQU16Masked256 (VPSHUFHW256 [a] x) mask) => (VPSHUFHWMasked256 [a] x mask)
(VMOVDQU16Masked512 (VPSHUFHW512 [a] x) mask) => (VPSHUFHWMasked512 [a] x mask)
+(VMOVDQU16Masked128 (VPSHUFHW128 [a] x) mask) => (VPSHUFHWMasked128 [a] x mask)
+(VMOVDQU32Masked128 (VPSHUFD128 [a] x) mask) => (VPSHUFDMasked128 [a] x mask)
+(VMOVDQU8Masked256 (VPSHUFB256 x y) mask) => (VPSHUFBMasked256 x y mask)
(VMOVDQU8Masked512 (VPSHUFB512 x y) mask) => (VPSHUFBMasked512 x y mask)
+(VMOVDQU8Masked128 (VPSHUFB128 x y) mask) => (VPSHUFBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPERMB256 x y) mask) => (VPERMBMasked256 x y mask)
(VMOVDQU8Masked512 (VPERMB512 x y) mask) => (VPERMBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPERMW128 x y) mask) => (VPERMWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPERMW256 x y) mask) => (VPERMWMasked256 x y mask)
(VMOVDQU16Masked512 (VPERMW512 x y) mask) => (VPERMWMasked512 x y mask)
+(VMOVDQU32Masked256 (VPERMPS256 x y) mask) => (VPERMPSMasked256 x y mask)
+(VMOVDQU32Masked256 (VPERMD256 x y) mask) => (VPERMDMasked256 x y mask)
(VMOVDQU32Masked512 (VPERMPS512 x y) mask) => (VPERMPSMasked512 x y mask)
(VMOVDQU32Masked512 (VPERMD512 x y) mask) => (VPERMDMasked512 x y mask)
+(VMOVDQU64Masked256 (VPERMPD256 x y) mask) => (VPERMPDMasked256 x y mask)
+(VMOVDQU64Masked256 (VPERMQ256 x y) mask) => (VPERMQMasked256 x y mask)
(VMOVDQU64Masked512 (VPERMPD512 x y) mask) => (VPERMPDMasked512 x y mask)
(VMOVDQU64Masked512 (VPERMQ512 x y) mask) => (VPERMQMasked512 x y mask)
(VMOVDQU32Masked512 (VRCP14PS512 x) mask) => (VRCP14PSMasked512 x mask)
+(VMOVDQU64Masked128 (VRCP14PD128 x) mask) => (VRCP14PDMasked128 x mask)
+(VMOVDQU64Masked256 (VRCP14PD256 x) mask) => (VRCP14PDMasked256 x mask)
(VMOVDQU64Masked512 (VRCP14PD512 x) mask) => (VRCP14PDMasked512 x mask)
(VMOVDQU32Masked512 (VRSQRT14PS512 x) mask) => (VRSQRT14PSMasked512 x mask)
+(VMOVDQU64Masked128 (VRSQRT14PD128 x) mask) => (VRSQRT14PDMasked128 x mask)
+(VMOVDQU64Masked256 (VRSQRT14PD256 x) mask) => (VRSQRT14PDMasked256 x mask)
(VMOVDQU64Masked512 (VRSQRT14PD512 x) mask) => (VRSQRT14PDMasked512 x mask)
+(VMOVDQU32Masked128 (VPROLD128 [a] x) mask) => (VPROLDMasked128 [a] x mask)
+(VMOVDQU32Masked256 (VPROLD256 [a] x) mask) => (VPROLDMasked256 [a] x mask)
(VMOVDQU32Masked512 (VPROLD512 [a] x) mask) => (VPROLDMasked512 [a] x mask)
+(VMOVDQU64Masked128 (VPROLQ128 [a] x) mask) => (VPROLQMasked128 [a] x mask)
+(VMOVDQU64Masked256 (VPROLQ256 [a] x) mask) => (VPROLQMasked256 [a] x mask)
(VMOVDQU64Masked512 (VPROLQ512 [a] x) mask) => (VPROLQMasked512 [a] x mask)
+(VMOVDQU32Masked128 (VPRORD128 [a] x) mask) => (VPRORDMasked128 [a] x mask)
+(VMOVDQU32Masked256 (VPRORD256 [a] x) mask) => (VPRORDMasked256 [a] x mask)
(VMOVDQU32Masked512 (VPRORD512 [a] x) mask) => (VPRORDMasked512 [a] x mask)
+(VMOVDQU64Masked128 (VPRORQ128 [a] x) mask) => (VPRORQMasked128 [a] x mask)
+(VMOVDQU64Masked256 (VPRORQ256 [a] x) mask) => (VPRORQMasked256 [a] x mask)
(VMOVDQU64Masked512 (VPRORQ512 [a] x) mask) => (VPRORQMasked512 [a] x mask)
+(VMOVDQU32Masked128 (VPROLVD128 x y) mask) => (VPROLVDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPROLVD256 x y) mask) => (VPROLVDMasked256 x y mask)
(VMOVDQU32Masked512 (VPROLVD512 x y) mask) => (VPROLVDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPROLVQ128 x y) mask) => (VPROLVQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPROLVQ256 x y) mask) => (VPROLVQMasked256 x y mask)
(VMOVDQU64Masked512 (VPROLVQ512 x y) mask) => (VPROLVQMasked512 x y mask)
+(VMOVDQU32Masked128 (VPRORVD128 x y) mask) => (VPRORVDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPRORVD256 x y) mask) => (VPRORVDMasked256 x y mask)
(VMOVDQU32Masked512 (VPRORVD512 x y) mask) => (VPRORVDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPRORVQ128 x y) mask) => (VPRORVQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPRORVQ256 x y) mask) => (VPRORVQMasked256 x y mask)
(VMOVDQU64Masked512 (VPRORVQ512 x y) mask) => (VPRORVQMasked512 x y mask)
+(VMOVDQU32Masked128 (VSCALEFPS128 x y) mask) => (VSCALEFPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VSCALEFPS256 x y) mask) => (VSCALEFPSMasked256 x y mask)
(VMOVDQU32Masked512 (VSCALEFPS512 x y) mask) => (VSCALEFPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VSCALEFPD128 x y) mask) => (VSCALEFPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VSCALEFPD256 x y) mask) => (VSCALEFPDMasked256 x y mask)
(VMOVDQU64Masked512 (VSCALEFPD512 x y) mask) => (VSCALEFPDMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSHLDW128 [a] x y) mask) => (VPSHLDWMasked128 [a] x y mask)
+(VMOVDQU16Masked256 (VPSHLDW256 [a] x y) mask) => (VPSHLDWMasked256 [a] x y mask)
(VMOVDQU16Masked512 (VPSHLDW512 [a] x y) mask) => (VPSHLDWMasked512 [a] x y mask)
+(VMOVDQU32Masked128 (VPSHLDD128 [a] x y) mask) => (VPSHLDDMasked128 [a] x y mask)
+(VMOVDQU32Masked256 (VPSHLDD256 [a] x y) mask) => (VPSHLDDMasked256 [a] x y mask)
(VMOVDQU32Masked512 (VPSHLDD512 [a] x y) mask) => (VPSHLDDMasked512 [a] x y mask)
+(VMOVDQU64Masked128 (VPSHLDQ128 [a] x y) mask) => (VPSHLDQMasked128 [a] x y mask)
+(VMOVDQU64Masked256 (VPSHLDQ256 [a] x y) mask) => (VPSHLDQMasked256 [a] x y mask)
(VMOVDQU64Masked512 (VPSHLDQ512 [a] x y) mask) => (VPSHLDQMasked512 [a] x y mask)
+(VMOVDQU16Masked128 (VPSLLW128 x y) mask) => (VPSLLWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSLLW256 x y) mask) => (VPSLLWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSLLW512 x y) mask) => (VPSLLWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSLLD128 x y) mask) => (VPSLLDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSLLD256 x y) mask) => (VPSLLDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSLLD512 x y) mask) => (VPSLLDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSLLQ128 x y) mask) => (VPSLLQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSLLQ256 x y) mask) => (VPSLLQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSLLQ512 x y) mask) => (VPSLLQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSHRDW128 [a] x y) mask) => (VPSHRDWMasked128 [a] x y mask)
+(VMOVDQU16Masked256 (VPSHRDW256 [a] x y) mask) => (VPSHRDWMasked256 [a] x y mask)
(VMOVDQU16Masked512 (VPSHRDW512 [a] x y) mask) => (VPSHRDWMasked512 [a] x y mask)
+(VMOVDQU32Masked128 (VPSHRDD128 [a] x y) mask) => (VPSHRDDMasked128 [a] x y mask)
+(VMOVDQU32Masked256 (VPSHRDD256 [a] x y) mask) => (VPSHRDDMasked256 [a] x y mask)
(VMOVDQU32Masked512 (VPSHRDD512 [a] x y) mask) => (VPSHRDDMasked512 [a] x y mask)
+(VMOVDQU64Masked128 (VPSHRDQ128 [a] x y) mask) => (VPSHRDQMasked128 [a] x y mask)
+(VMOVDQU64Masked256 (VPSHRDQ256 [a] x y) mask) => (VPSHRDQMasked256 [a] x y mask)
(VMOVDQU64Masked512 (VPSHRDQ512 [a] x y) mask) => (VPSHRDQMasked512 [a] x y mask)
+(VMOVDQU16Masked128 (VPSRAW128 x y) mask) => (VPSRAWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSRAW256 x y) mask) => (VPSRAWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSRAW512 x y) mask) => (VPSRAWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSRAD128 x y) mask) => (VPSRADMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSRAD256 x y) mask) => (VPSRADMasked256 x y mask)
(VMOVDQU32Masked512 (VPSRAD512 x y) mask) => (VPSRADMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSRAQ128 x y) mask) => (VPSRAQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSRAQ256 x y) mask) => (VPSRAQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSRAQ512 x y) mask) => (VPSRAQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSRLW128 x y) mask) => (VPSRLWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSRLW256 x y) mask) => (VPSRLWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSRLW512 x y) mask) => (VPSRLWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSRLD128 x y) mask) => (VPSRLDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSRLD256 x y) mask) => (VPSRLDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSRLD512 x y) mask) => (VPSRLDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSRLQ128 x y) mask) => (VPSRLQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSRLQ256 x y) mask) => (VPSRLQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSRLQ512 x y) mask) => (VPSRLQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSHLDVW128 x y z) mask) => (VPSHLDVWMasked128 x y z mask)
+(VMOVDQU16Masked256 (VPSHLDVW256 x y z) mask) => (VPSHLDVWMasked256 x y z mask)
(VMOVDQU16Masked512 (VPSHLDVW512 x y z) mask) => (VPSHLDVWMasked512 x y z mask)
+(VMOVDQU32Masked128 (VPSHLDVD128 x y z) mask) => (VPSHLDVDMasked128 x y z mask)
+(VMOVDQU32Masked256 (VPSHLDVD256 x y z) mask) => (VPSHLDVDMasked256 x y z mask)
(VMOVDQU32Masked512 (VPSHLDVD512 x y z) mask) => (VPSHLDVDMasked512 x y z mask)
+(VMOVDQU64Masked128 (VPSHLDVQ128 x y z) mask) => (VPSHLDVQMasked128 x y z mask)
+(VMOVDQU64Masked256 (VPSHLDVQ256 x y z) mask) => (VPSHLDVQMasked256 x y z mask)
(VMOVDQU64Masked512 (VPSHLDVQ512 x y z) mask) => (VPSHLDVQMasked512 x y z mask)
+(VMOVDQU16Masked128 (VPSLLVW128 x y) mask) => (VPSLLVWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSLLVW256 x y) mask) => (VPSLLVWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSLLVW512 x y) mask) => (VPSLLVWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSLLVD128 x y) mask) => (VPSLLVDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSLLVD256 x y) mask) => (VPSLLVDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSLLVD512 x y) mask) => (VPSLLVDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSLLVQ128 x y) mask) => (VPSLLVQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSLLVQ256 x y) mask) => (VPSLLVQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSLLVQ512 x y) mask) => (VPSLLVQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSHRDVW128 x y z) mask) => (VPSHRDVWMasked128 x y z mask)
+(VMOVDQU16Masked256 (VPSHRDVW256 x y z) mask) => (VPSHRDVWMasked256 x y z mask)
(VMOVDQU16Masked512 (VPSHRDVW512 x y z) mask) => (VPSHRDVWMasked512 x y z mask)
+(VMOVDQU32Masked128 (VPSHRDVD128 x y z) mask) => (VPSHRDVDMasked128 x y z mask)
+(VMOVDQU32Masked256 (VPSHRDVD256 x y z) mask) => (VPSHRDVDMasked256 x y z mask)
(VMOVDQU32Masked512 (VPSHRDVD512 x y z) mask) => (VPSHRDVDMasked512 x y z mask)
+(VMOVDQU64Masked128 (VPSHRDVQ128 x y z) mask) => (VPSHRDVQMasked128 x y z mask)
+(VMOVDQU64Masked256 (VPSHRDVQ256 x y z) mask) => (VPSHRDVQMasked256 x y z mask)
(VMOVDQU64Masked512 (VPSHRDVQ512 x y z) mask) => (VPSHRDVQMasked512 x y z mask)
+(VMOVDQU16Masked128 (VPSRAVW128 x y) mask) => (VPSRAVWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSRAVW256 x y) mask) => (VPSRAVWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSRAVW512 x y) mask) => (VPSRAVWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSRAVD128 x y) mask) => (VPSRAVDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSRAVD256 x y) mask) => (VPSRAVDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSRAVD512 x y) mask) => (VPSRAVDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSRAVQ128 x y) mask) => (VPSRAVQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSRAVQ256 x y) mask) => (VPSRAVQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSRAVQ512 x y) mask) => (VPSRAVQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSRLVW128 x y) mask) => (VPSRLVWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSRLVW256 x y) mask) => (VPSRLVWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSRLVW512 x y) mask) => (VPSRLVWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSRLVD128 x y) mask) => (VPSRLVDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSRLVD256 x y) mask) => (VPSRLVDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSRLVD512 x y) mask) => (VPSRLVDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSRLVQ128 x y) mask) => (VPSRLVQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSRLVQ256 x y) mask) => (VPSRLVQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSRLVQ512 x y) mask) => (VPSRLVQMasked512 x y mask)
+(VMOVDQU32Masked128 (VSQRTPS128 x) mask) => (VSQRTPSMasked128 x mask)
+(VMOVDQU32Masked256 (VSQRTPS256 x) mask) => (VSQRTPSMasked256 x mask)
(VMOVDQU32Masked512 (VSQRTPS512 x) mask) => (VSQRTPSMasked512 x mask)
+(VMOVDQU64Masked128 (VSQRTPD128 x) mask) => (VSQRTPDMasked128 x mask)
+(VMOVDQU64Masked256 (VSQRTPD256 x) mask) => (VSQRTPDMasked256 x mask)
(VMOVDQU64Masked512 (VSQRTPD512 x) mask) => (VSQRTPDMasked512 x mask)
+(VMOVDQU32Masked128 (VSUBPS128 x y) mask) => (VSUBPSMasked128 x y mask)
+(VMOVDQU32Masked256 (VSUBPS256 x y) mask) => (VSUBPSMasked256 x y mask)
(VMOVDQU32Masked512 (VSUBPS512 x y) mask) => (VSUBPSMasked512 x y mask)
+(VMOVDQU64Masked128 (VSUBPD128 x y) mask) => (VSUBPDMasked128 x y mask)
+(VMOVDQU64Masked256 (VSUBPD256 x y) mask) => (VSUBPDMasked256 x y mask)
(VMOVDQU64Masked512 (VSUBPD512 x y) mask) => (VSUBPDMasked512 x y mask)
+(VMOVDQU8Masked128 (VPSUBB128 x y) mask) => (VPSUBBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPSUBB256 x y) mask) => (VPSUBBMasked256 x y mask)
(VMOVDQU8Masked512 (VPSUBB512 x y) mask) => (VPSUBBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSUBW128 x y) mask) => (VPSUBWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSUBW256 x y) mask) => (VPSUBWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSUBW512 x y) mask) => (VPSUBWMasked512 x y mask)
+(VMOVDQU32Masked128 (VPSUBD128 x y) mask) => (VPSUBDMasked128 x y mask)
+(VMOVDQU32Masked256 (VPSUBD256 x y) mask) => (VPSUBDMasked256 x y mask)
(VMOVDQU32Masked512 (VPSUBD512 x y) mask) => (VPSUBDMasked512 x y mask)
+(VMOVDQU64Masked128 (VPSUBQ128 x y) mask) => (VPSUBQMasked128 x y mask)
+(VMOVDQU64Masked256 (VPSUBQ256 x y) mask) => (VPSUBQMasked256 x y mask)
(VMOVDQU64Masked512 (VPSUBQ512 x y) mask) => (VPSUBQMasked512 x y mask)
+(VMOVDQU8Masked128 (VPSUBSB128 x y) mask) => (VPSUBSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPSUBSB256 x y) mask) => (VPSUBSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPSUBSB512 x y) mask) => (VPSUBSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSUBSW128 x y) mask) => (VPSUBSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSUBSW256 x y) mask) => (VPSUBSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSUBSW512 x y) mask) => (VPSUBSWMasked512 x y mask)
+(VMOVDQU8Masked128 (VPSUBUSB128 x y) mask) => (VPSUBUSBMasked128 x y mask)
+(VMOVDQU8Masked256 (VPSUBUSB256 x y) mask) => (VPSUBUSBMasked256 x y mask)
(VMOVDQU8Masked512 (VPSUBUSB512 x y) mask) => (VPSUBUSBMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSUBUSW128 x y) mask) => (VPSUBUSWMasked128 x y mask)
+(VMOVDQU16Masked256 (VPSUBUSW256 x y) mask) => (VPSUBUSWMasked256 x y mask)
(VMOVDQU16Masked512 (VPSUBUSW512 x y) mask) => (VPSUBUSWMasked512 x y mask)
(VMOVDQU32Masked512 (VPXORD512 x y) mask) => (VPXORDMasked512 x y mask)
(VMOVDQU64Masked512 (VPXORQ512 x y) mask) => (VPXORQMasked512 x y mask)
+(VMOVDQU16Masked128 (VPSLLW128const [a] x) mask) => (VPSLLWMasked128const [a] x mask)
+(VMOVDQU16Masked256 (VPSLLW256const [a] x) mask) => (VPSLLWMasked256const [a] x mask)
(VMOVDQU16Masked512 (VPSLLW512const [a] x) mask) => (VPSLLWMasked512const [a] x mask)
+(VMOVDQU32Masked128 (VPSLLD128const [a] x) mask) => (VPSLLDMasked128const [a] x mask)
+(VMOVDQU32Masked256 (VPSLLD256const [a] x) mask) => (VPSLLDMasked256const [a] x mask)
(VMOVDQU32Masked512 (VPSLLD512const [a] x) mask) => (VPSLLDMasked512const [a] x mask)
+(VMOVDQU64Masked128 (VPSLLQ128const [a] x) mask) => (VPSLLQMasked128const [a] x mask)
+(VMOVDQU64Masked256 (VPSLLQ256const [a] x) mask) => (VPSLLQMasked256const [a] x mask)
(VMOVDQU64Masked512 (VPSLLQ512const [a] x) mask) => (VPSLLQMasked512const [a] x mask)
-(VMOVDQU16Masked512 (VPSRLW512const [a] x) mask) => (VPSRLWMasked512const [a] x mask)
-(VMOVDQU32Masked512 (VPSRLD512const [a] x) mask) => (VPSRLDMasked512const [a] x mask)
-(VMOVDQU64Masked512 (VPSRLQ512const [a] x) mask) => (VPSRLQMasked512const [a] x mask)
+(VMOVDQU16Masked128 (VPSRAW128const [a] x) mask) => (VPSRAWMasked128const [a] x mask)
+(VMOVDQU16Masked256 (VPSRAW256const [a] x) mask) => (VPSRAWMasked256const [a] x mask)
(VMOVDQU16Masked512 (VPSRAW512const [a] x) mask) => (VPSRAWMasked512const [a] x mask)
+(VMOVDQU32Masked128 (VPSRAD128const [a] x) mask) => (VPSRADMasked128const [a] x mask)
+(VMOVDQU32Masked256 (VPSRAD256const [a] x) mask) => (VPSRADMasked256const [a] x mask)
(VMOVDQU32Masked512 (VPSRAD512const [a] x) mask) => (VPSRADMasked512const [a] x mask)
+(VMOVDQU64Masked128 (VPSRAQ128const [a] x) mask) => (VPSRAQMasked128const [a] x mask)
+(VMOVDQU64Masked256 (VPSRAQ256const [a] x) mask) => (VPSRAQMasked256const [a] x mask)
(VMOVDQU64Masked512 (VPSRAQ512const [a] x) mask) => (VPSRAQMasked512const [a] x mask)
(VPABSD512 l:(VMOVDQUload512 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPABSD512load {sym} [off] ptr mem)
(VPABSQ128 l:(VMOVDQUload128 {sym} [off] ptr mem)) && canMergeLoad(v, l) && clobber(l) => (VPABSQ128load {sym} [off] ptr mem)
return rewriteValueAMD64_OpAMD64VMINPSMasked512(v)
case OpAMD64VMOVD:
return rewriteValueAMD64_OpAMD64VMOVD(v)
+ case OpAMD64VMOVDQU16Masked128:
+ return rewriteValueAMD64_OpAMD64VMOVDQU16Masked128(v)
+ case OpAMD64VMOVDQU16Masked256:
+ return rewriteValueAMD64_OpAMD64VMOVDQU16Masked256(v)
case OpAMD64VMOVDQU16Masked512:
return rewriteValueAMD64_OpAMD64VMOVDQU16Masked512(v)
+ case OpAMD64VMOVDQU32Masked128:
+ return rewriteValueAMD64_OpAMD64VMOVDQU32Masked128(v)
+ case OpAMD64VMOVDQU32Masked256:
+ return rewriteValueAMD64_OpAMD64VMOVDQU32Masked256(v)
case OpAMD64VMOVDQU32Masked512:
return rewriteValueAMD64_OpAMD64VMOVDQU32Masked512(v)
+ case OpAMD64VMOVDQU64Masked128:
+ return rewriteValueAMD64_OpAMD64VMOVDQU64Masked128(v)
+ case OpAMD64VMOVDQU64Masked256:
+ return rewriteValueAMD64_OpAMD64VMOVDQU64Masked256(v)
case OpAMD64VMOVDQU64Masked512:
return rewriteValueAMD64_OpAMD64VMOVDQU64Masked512(v)
+ case OpAMD64VMOVDQU8Masked128:
+ return rewriteValueAMD64_OpAMD64VMOVDQU8Masked128(v)
+ case OpAMD64VMOVDQU8Masked256:
+ return rewriteValueAMD64_OpAMD64VMOVDQU8Masked256(v)
case OpAMD64VMOVDQU8Masked512:
return rewriteValueAMD64_OpAMD64VMOVDQU8Masked512(v)
case OpAMD64VMOVDQUload128:
return rewriteValueAMD64_OpAMD64VPADDQMasked256(v)
case OpAMD64VPADDQMasked512:
return rewriteValueAMD64_OpAMD64VPADDQMasked512(v)
+ case OpAMD64VPAND128:
+ return rewriteValueAMD64_OpAMD64VPAND128(v)
+ case OpAMD64VPAND256:
+ return rewriteValueAMD64_OpAMD64VPAND256(v)
case OpAMD64VPANDD512:
return rewriteValueAMD64_OpAMD64VPANDD512(v)
case OpAMD64VPANDDMasked128:
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU16Masked512(v *Value) bool {
+func rewriteValueAMD64_OpAMD64VMOVDQU16Masked128(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
- // match: (VMOVDQU16Masked512 (VPABSW512 x) mask)
- // result: (VPABSWMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPABSW128 x) mask)
+ // result: (VPABSWMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPABSW512 {
+ if v_0.Op != OpAMD64VPABSW128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPABSWMasked512)
+ v.reset(OpAMD64VPABSWMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPADDW512 x y) mask)
- // result: (VPADDWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPADDW128 x y) mask)
+ // result: (VPADDWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPADDW512 {
+ if v_0.Op != OpAMD64VPADDW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPADDWMasked512)
+ v.reset(OpAMD64VPADDWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPADDSW512 x y) mask)
- // result: (VPADDSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPADDSW128 x y) mask)
+ // result: (VPADDSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPADDSW512 {
+ if v_0.Op != OpAMD64VPADDSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPADDSWMasked512)
+ v.reset(OpAMD64VPADDSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPADDUSW512 x y) mask)
- // result: (VPADDUSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPADDUSW128 x y) mask)
+ // result: (VPADDUSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPADDUSW512 {
+ if v_0.Op != OpAMD64VPADDUSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPADDUSWMasked512)
+ v.reset(OpAMD64VPADDUSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPAVGW512 x y) mask)
- // result: (VPAVGWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPAVGW128 x y) mask)
+ // result: (VPAVGWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPAVGW512 {
+ if v_0.Op != OpAMD64VPAVGW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPAVGWMasked512)
+ v.reset(OpAMD64VPAVGWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPBROADCASTW512 x) mask)
- // result: (VPBROADCASTWMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPBROADCASTW128 x) mask)
+ // result: (VPBROADCASTWMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPBROADCASTW512 {
+ if v_0.Op != OpAMD64VPBROADCASTW128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPBROADCASTWMasked512)
+ v.reset(OpAMD64VPBROADCASTWMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMOVSXWD512 x) mask)
- // result: (VPMOVSXWDMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPMOVWB128 x) mask)
+ // result: (VPMOVWBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPMOVSXWD512 {
+ if v_0.Op != OpAMD64VPMOVWB128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVSXWDMasked512)
+ v.reset(OpAMD64VPMOVWBMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMOVSXWQ512 x) mask)
- // result: (VPMOVSXWQMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPMOVSWB128 x) mask)
+ // result: (VPMOVSWBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPMOVSXWQ512 {
+ if v_0.Op != OpAMD64VPMOVSWB128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVSXWQMasked512)
+ v.reset(OpAMD64VPMOVSWBMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMOVZXWD512 x) mask)
- // result: (VPMOVZXWDMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPMOVSXWD128 x) mask)
+ // result: (VPMOVSXWDMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPMOVZXWD512 {
+ if v_0.Op != OpAMD64VPMOVSXWD128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVZXWDMasked512)
+ v.reset(OpAMD64VPMOVSXWDMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMOVZXWQ512 x) mask)
- // result: (VPMOVZXWQMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPMOVSXWQ128 x) mask)
+ // result: (VPMOVSXWQMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPMOVZXWQ512 {
+ if v_0.Op != OpAMD64VPMOVSXWQ128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVZXWQMasked512)
+ v.reset(OpAMD64VPMOVSXWQMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMADDWD512 x y) mask)
- // result: (VPMADDWDMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMOVUSWB128 x) mask)
+ // result: (VPMOVUSWBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPMADDWD512 {
+ if v_0.Op != OpAMD64VPMOVUSWB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSWBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked128 (VPMOVZXWD128 x) mask)
+ // result: (VPMOVZXWDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXWD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXWDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked128 (VPMOVZXWQ128 x) mask)
+ // result: (VPMOVZXWQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXWQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXWQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked128 (VPMADDWD128 x y) mask)
+ // result: (VPMADDWDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMADDWD128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMADDWDMasked512)
+ v.reset(OpAMD64VPMADDWDMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMADDUBSW512 x y) mask)
- // result: (VPMADDUBSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMADDUBSW128 x y) mask)
+ // result: (VPMADDUBSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMADDUBSW512 {
+ if v_0.Op != OpAMD64VPMADDUBSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMADDUBSWMasked512)
+ v.reset(OpAMD64VPMADDUBSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMAXSW512 x y) mask)
- // result: (VPMAXSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMAXSW128 x y) mask)
+ // result: (VPMAXSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMAXSW512 {
+ if v_0.Op != OpAMD64VPMAXSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXSWMasked512)
+ v.reset(OpAMD64VPMAXSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMAXUW512 x y) mask)
- // result: (VPMAXUWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMAXUW128 x y) mask)
+ // result: (VPMAXUWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMAXUW512 {
+ if v_0.Op != OpAMD64VPMAXUW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXUWMasked512)
+ v.reset(OpAMD64VPMAXUWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMINSW512 x y) mask)
- // result: (VPMINSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMINSW128 x y) mask)
+ // result: (VPMINSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMINSW512 {
+ if v_0.Op != OpAMD64VPMINSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMINSWMasked512)
+ v.reset(OpAMD64VPMINSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMINUW512 x y) mask)
- // result: (VPMINUWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMINUW128 x y) mask)
+ // result: (VPMINUWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMINUW512 {
+ if v_0.Op != OpAMD64VPMINUW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMINUWMasked512)
+ v.reset(OpAMD64VPMINUWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMULHW512 x y) mask)
- // result: (VPMULHWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMULHW128 x y) mask)
+ // result: (VPMULHWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMULHW512 {
+ if v_0.Op != OpAMD64VPMULHW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMULHWMasked512)
+ v.reset(OpAMD64VPMULHWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMULHUW512 x y) mask)
- // result: (VPMULHUWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMULHUW128 x y) mask)
+ // result: (VPMULHUWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMULHUW512 {
+ if v_0.Op != OpAMD64VPMULHUW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMULHUWMasked512)
+ v.reset(OpAMD64VPMULHUWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPMULLW512 x y) mask)
- // result: (VPMULLWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPMULLW128 x y) mask)
+ // result: (VPMULLWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMULLW512 {
+ if v_0.Op != OpAMD64VPMULLW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMULLWMasked512)
+ v.reset(OpAMD64VPMULLWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPOPCNTW512 x) mask)
- // result: (VPOPCNTWMasked512 x mask)
+ // match: (VMOVDQU16Masked128 (VPOPCNTW128 x) mask)
+ // result: (VPOPCNTWMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPOPCNTW512 {
+ if v_0.Op != OpAMD64VPOPCNTW128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPOPCNTWMasked512)
+ v.reset(OpAMD64VPOPCNTWMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPERMI2W512 x y z) mask)
- // result: (VPERMI2WMasked512 x y z mask)
+ // match: (VMOVDQU16Masked128 (VPERMI2W128 x y z) mask)
+ // result: (VPERMI2WMasked128 x y z mask)
for {
- if v_0.Op != OpAMD64VPERMI2W512 {
+ if v_0.Op != OpAMD64VPERMI2W128 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPERMI2WMasked512)
+ v.reset(OpAMD64VPERMI2WMasked128)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSHUFHW512 [a] x) mask)
- // result: (VPSHUFHWMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked128 (VPSHUFHW128 [a] x) mask)
+ // result: (VPSHUFHWMasked128 [a] x mask)
for {
- if v_0.Op != OpAMD64VPSHUFHW512 {
+ if v_0.Op != OpAMD64VPSHUFHW128 {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHUFHWMasked512)
+ v.reset(OpAMD64VPSHUFHWMasked128)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPERMW512 x y) mask)
- // result: (VPERMWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPERMW128 x y) mask)
+ // result: (VPERMWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPERMW512 {
+ if v_0.Op != OpAMD64VPERMW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMWMasked512)
+ v.reset(OpAMD64VPERMWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSHLDW512 [a] x y) mask)
- // result: (VPSHLDWMasked512 [a] x y mask)
+ // match: (VMOVDQU16Masked128 (VPSHLDW128 [a] x y) mask)
+ // result: (VPSHLDWMasked128 [a] x y mask)
for {
- if v_0.Op != OpAMD64VPSHLDW512 {
+ if v_0.Op != OpAMD64VPSHLDW128 {
break
}
a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHLDWMasked512)
+ v.reset(OpAMD64VPSHLDWMasked128)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSLLW512 x y) mask)
- // result: (VPSLLWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSLLW128 x y) mask)
+ // result: (VPSLLWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSLLW512 {
+ if v_0.Op != OpAMD64VPSLLW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLWMasked512)
+ v.reset(OpAMD64VPSLLWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSHRDW512 [a] x y) mask)
- // result: (VPSHRDWMasked512 [a] x y mask)
+ // match: (VMOVDQU16Masked128 (VPSHRDW128 [a] x y) mask)
+ // result: (VPSHRDWMasked128 [a] x y mask)
for {
- if v_0.Op != OpAMD64VPSHRDW512 {
+ if v_0.Op != OpAMD64VPSHRDW128 {
break
}
a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHRDWMasked512)
+ v.reset(OpAMD64VPSHRDWMasked128)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSRAW512 x y) mask)
- // result: (VPSRAWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSRAW128 x y) mask)
+ // result: (VPSRAWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAW512 {
+ if v_0.Op != OpAMD64VPSRAW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAWMasked512)
+ v.reset(OpAMD64VPSRAWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSRLW512 x y) mask)
- // result: (VPSRLWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSRLW128 x y) mask)
+ // result: (VPSRLWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLW512 {
+ if v_0.Op != OpAMD64VPSRLW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLWMasked512)
+ v.reset(OpAMD64VPSRLWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSHLDVW512 x y z) mask)
- // result: (VPSHLDVWMasked512 x y z mask)
+ // match: (VMOVDQU16Masked128 (VPSHLDVW128 x y z) mask)
+ // result: (VPSHLDVWMasked128 x y z mask)
for {
- if v_0.Op != OpAMD64VPSHLDVW512 {
+ if v_0.Op != OpAMD64VPSHLDVW128 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPSHLDVWMasked512)
+ v.reset(OpAMD64VPSHLDVWMasked128)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSLLVW512 x y) mask)
- // result: (VPSLLVWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSLLVW128 x y) mask)
+ // result: (VPSLLVWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSLLVW512 {
+ if v_0.Op != OpAMD64VPSLLVW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLVWMasked512)
+ v.reset(OpAMD64VPSLLVWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSHRDVW512 x y z) mask)
- // result: (VPSHRDVWMasked512 x y z mask)
+ // match: (VMOVDQU16Masked128 (VPSHRDVW128 x y z) mask)
+ // result: (VPSHRDVWMasked128 x y z mask)
for {
- if v_0.Op != OpAMD64VPSHRDVW512 {
+ if v_0.Op != OpAMD64VPSHRDVW128 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPSHRDVWMasked512)
+ v.reset(OpAMD64VPSHRDVWMasked128)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSRAVW512 x y) mask)
- // result: (VPSRAVWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSRAVW128 x y) mask)
+ // result: (VPSRAVWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAVW512 {
+ if v_0.Op != OpAMD64VPSRAVW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAVWMasked512)
+ v.reset(OpAMD64VPSRAVWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSRLVW512 x y) mask)
- // result: (VPSRLVWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSRLVW128 x y) mask)
+ // result: (VPSRLVWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLVW512 {
+ if v_0.Op != OpAMD64VPSRLVW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLVWMasked512)
+ v.reset(OpAMD64VPSRLVWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSUBW512 x y) mask)
- // result: (VPSUBWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSUBW128 x y) mask)
+ // result: (VPSUBWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSUBW512 {
+ if v_0.Op != OpAMD64VPSUBW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSUBWMasked512)
+ v.reset(OpAMD64VPSUBWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSUBSW512 x y) mask)
- // result: (VPSUBSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSUBSW128 x y) mask)
+ // result: (VPSUBSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSUBSW512 {
+ if v_0.Op != OpAMD64VPSUBSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSUBSWMasked512)
+ v.reset(OpAMD64VPSUBSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSUBUSW512 x y) mask)
- // result: (VPSUBUSWMasked512 x y mask)
+ // match: (VMOVDQU16Masked128 (VPSUBUSW128 x y) mask)
+ // result: (VPSUBUSWMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPSUBUSW512 {
+ if v_0.Op != OpAMD64VPSUBUSW128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSUBUSWMasked512)
+ v.reset(OpAMD64VPSUBUSWMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSLLW512const [a] x) mask)
- // result: (VPSLLWMasked512const [a] x mask)
- for {
- if v_0.Op != OpAMD64VPSLLW512const {
- break
- }
- a := auxIntToUint8(v_0.AuxInt)
- x := v_0.Args[0]
- mask := v_1
- v.reset(OpAMD64VPSLLWMasked512const)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg2(x, mask)
- return true
- }
- // match: (VMOVDQU16Masked512 (VPSRLW512const [a] x) mask)
- // result: (VPSRLWMasked512const [a] x mask)
+ // match: (VMOVDQU16Masked128 (VPSLLW128const [a] x) mask)
+ // result: (VPSLLWMasked128const [a] x mask)
for {
- if v_0.Op != OpAMD64VPSRLW512const {
+ if v_0.Op != OpAMD64VPSLLW128const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLWMasked512const)
+ v.reset(OpAMD64VPSLLWMasked128const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU16Masked512 (VPSRAW512const [a] x) mask)
- // result: (VPSRAWMasked512const [a] x mask)
+ // match: (VMOVDQU16Masked128 (VPSRAW128const [a] x) mask)
+ // result: (VPSRAWMasked128const [a] x mask)
for {
- if v_0.Op != OpAMD64VPSRAW512const {
+ if v_0.Op != OpAMD64VPSRAW128const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAWMasked512const)
+ v.reset(OpAMD64VPSRAWMasked128const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
return false
}
-func rewriteValueAMD64_OpAMD64VMOVDQU32Masked512(v *Value) bool {
+func rewriteValueAMD64_OpAMD64VMOVDQU16Masked256(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
- // match: (VMOVDQU32Masked512 (VPABSD512 x) mask)
- // result: (VPABSDMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPABSW256 x) mask)
+ // result: (VPABSWMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPABSD512 {
+ if v_0.Op != OpAMD64VPABSW256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPABSDMasked512)
+ v.reset(OpAMD64VPABSWMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPDPWSSD512 x y z) mask)
- // result: (VPDPWSSDMasked512 x y z mask)
- for {
- if v_0.Op != OpAMD64VPDPWSSD512 {
- break
- }
- z := v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- mask := v_1
- v.reset(OpAMD64VPDPWSSDMasked512)
- v.AddArg4(x, y, z, mask)
- return true
- }
- // match: (VMOVDQU32Masked512 (VPDPBUSD512 x y z) mask)
- // result: (VPDPBUSDMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPADDW256 x y) mask)
+ // result: (VPADDWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPDPBUSD512 {
+ if v_0.Op != OpAMD64VPADDW256 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
y := v_0.Args[1]
- mask := v_1
- v.reset(OpAMD64VPDPBUSDMasked512)
- v.AddArg4(x, y, z, mask)
- return true
- }
- // match: (VMOVDQU32Masked512 (VPDPBUSDS512 x y z) mask)
- // result: (VPDPBUSDSMasked512 x y z mask)
- for {
- if v_0.Op != OpAMD64VPDPBUSDS512 {
- break
- }
- z := v_0.Args[2]
x := v_0.Args[0]
- y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPDPBUSDSMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPADDWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VADDPS512 x y) mask)
- // result: (VADDPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPADDSW256 x y) mask)
+ // result: (VPADDSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VADDPS512 {
+ if v_0.Op != OpAMD64VPADDSW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VADDPSMasked512)
+ v.reset(OpAMD64VPADDSWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPADDD512 x y) mask)
- // result: (VPADDDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPADDUSW256 x y) mask)
+ // result: (VPADDUSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPADDD512 {
+ if v_0.Op != OpAMD64VPADDUSW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPADDDMasked512)
+ v.reset(OpAMD64VPADDUSWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPANDD512 x y) mask)
- // result: (VPANDDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPAVGW256 x y) mask)
+ // result: (VPAVGWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPANDD512 {
+ if v_0.Op != OpAMD64VPAVGW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPANDDMasked512)
+ v.reset(OpAMD64VPAVGWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPANDND512 x y) mask)
- // result: (VPANDNDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPBROADCASTW256 x) mask)
+ // result: (VPBROADCASTWMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPANDND512 {
+ if v_0.Op != OpAMD64VPBROADCASTW256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPANDNDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPBROADCASTWMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VBROADCASTSS512 x) mask)
- // result: (VBROADCASTSSMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVWB256 x) mask)
+ // result: (VPMOVWBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VBROADCASTSS512 {
+ if v_0.Op != OpAMD64VPMOVWB256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VBROADCASTSSMasked512)
+ v.reset(OpAMD64VPMOVWBMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPBROADCASTD512 x) mask)
- // result: (VPBROADCASTDMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVSWB256 x) mask)
+ // result: (VPMOVSWBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPBROADCASTD512 {
+ if v_0.Op != OpAMD64VPMOVSWB256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPBROADCASTDMasked512)
+ v.reset(OpAMD64VPMOVSWBMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VRNDSCALEPS512 [a] x) mask)
- // result: (VRNDSCALEPSMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVSXWD256 x) mask)
+ // result: (VPMOVSXWDMasked256 x mask)
for {
- if v_0.Op != OpAMD64VRNDSCALEPS512 {
+ if v_0.Op != OpAMD64VPMOVSXWD256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRNDSCALEPSMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVSXWDMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VREDUCEPS512 [a] x) mask)
- // result: (VREDUCEPSMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVUSWB256 x) mask)
+ // result: (VPMOVUSWBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VREDUCEPS512 {
+ if v_0.Op != OpAMD64VPMOVUSWB256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VREDUCEPSMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVUSWBMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPACKSSDW512 x y) mask)
- // result: (VPACKSSDWMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMOVZXWD256 x) mask)
+ // result: (VPMOVZXWDMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPACKSSDW512 {
+ if v_0.Op != OpAMD64VPMOVZXWD256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPACKSSDWMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVZXWDMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VCVTTPS2DQ512 x) mask)
- // result: (VCVTTPS2DQMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVSXWQ256 x) mask)
+ // result: (VPMOVSXWQMasked256 x mask)
for {
- if v_0.Op != OpAMD64VCVTTPS2DQ512 {
+ if v_0.Op != OpAMD64VPMOVSXWQ256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VCVTTPS2DQMasked512)
+ v.reset(OpAMD64VPMOVSXWQMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMOVSXDQ512 x) mask)
- // result: (VPMOVSXDQMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMOVZXWQ256 x) mask)
+ // result: (VPMOVZXWQMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPMOVSXDQ512 {
+ if v_0.Op != OpAMD64VPMOVZXWQ256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVSXDQMasked512)
+ v.reset(OpAMD64VPMOVZXWQMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPACKUSDW512 x y) mask)
- // result: (VPACKUSDWMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMADDWD256 x y) mask)
+ // result: (VPMADDWDMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPACKUSDW512 {
+ if v_0.Op != OpAMD64VPMADDWD256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPACKUSDWMasked512)
+ v.reset(OpAMD64VPMADDWDMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VCVTPS2UDQ512 x) mask)
- // result: (VCVTPS2UDQMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMADDUBSW256 x y) mask)
+ // result: (VPMADDUBSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VCVTPS2UDQ512 {
+ if v_0.Op != OpAMD64VPMADDUBSW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VCVTPS2UDQMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPMADDUBSWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMOVZXDQ512 x) mask)
- // result: (VPMOVZXDQMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMAXSW256 x y) mask)
+ // result: (VPMAXSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPMOVZXDQ512 {
+ if v_0.Op != OpAMD64VPMAXSW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMOVZXDQMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPMAXSWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VDIVPS512 x y) mask)
- // result: (VDIVPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMAXUW256 x y) mask)
+ // result: (VPMAXUWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VDIVPS512 {
+ if v_0.Op != OpAMD64VPMAXUW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VDIVPSMasked512)
+ v.reset(OpAMD64VPMAXUWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPLZCNTD512 x) mask)
- // result: (VPLZCNTDMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPMINSW256 x y) mask)
+ // result: (VPMINSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPLZCNTD512 {
+ if v_0.Op != OpAMD64VPMINSW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPLZCNTDMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPMINSWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VMAXPS512 x y) mask)
- // result: (VMAXPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMINUW256 x y) mask)
+ // result: (VPMINUWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VMAXPS512 {
+ if v_0.Op != OpAMD64VPMINUW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VMAXPSMasked512)
+ v.reset(OpAMD64VPMINUWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMAXSD512 x y) mask)
- // result: (VPMAXSDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMULHW256 x y) mask)
+ // result: (VPMULHWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPMAXSD512 {
+ if v_0.Op != OpAMD64VPMULHW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXSDMasked512)
+ v.reset(OpAMD64VPMULHWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMAXUD512 x y) mask)
- // result: (VPMAXUDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMULHUW256 x y) mask)
+ // result: (VPMULHUWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPMAXUD512 {
+ if v_0.Op != OpAMD64VPMULHUW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXUDMasked512)
+ v.reset(OpAMD64VPMULHUWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VMINPS512 x y) mask)
- // result: (VMINPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPMULLW256 x y) mask)
+ // result: (VPMULLWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VMINPS512 {
+ if v_0.Op != OpAMD64VPMULLW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VMINPSMasked512)
+ v.reset(OpAMD64VPMULLWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMINSD512 x y) mask)
- // result: (VPMINSDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPOPCNTW256 x) mask)
+ // result: (VPOPCNTWMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPMINSD512 {
+ if v_0.Op != OpAMD64VPOPCNTW256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMINSDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPOPCNTWMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMINUD512 x y) mask)
- // result: (VPMINUDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPERMI2W256 x y z) mask)
+ // result: (VPERMI2WMasked256 x y z mask)
for {
- if v_0.Op != OpAMD64VPMINUD512 {
+ if v_0.Op != OpAMD64VPERMI2W256 {
break
}
- y := v_0.Args[1]
+ z := v_0.Args[2]
x := v_0.Args[0]
+ y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPMINUDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPERMI2WMasked256)
+ v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VFMADD213PS512 x y z) mask)
- // result: (VFMADD213PSMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPSHUFHW256 [a] x) mask)
+ // result: (VPSHUFHWMasked256 [a] x mask)
for {
- if v_0.Op != OpAMD64VFMADD213PS512 {
+ if v_0.Op != OpAMD64VPSHUFHW256 {
break
}
- z := v_0.Args[2]
+ a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
- y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VFMADD213PSMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPSHUFHWMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VFMADDSUB213PS512 x y z) mask)
- // result: (VFMADDSUB213PSMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPERMW256 x y) mask)
+ // result: (VPERMWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VFMADDSUB213PS512 {
+ if v_0.Op != OpAMD64VPERMW256 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
y := v_0.Args[1]
+ x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VFMADDSUB213PSMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPERMWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VMULPS512 x y) mask)
- // result: (VMULPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPSHLDW256 [a] x y) mask)
+ // result: (VPSHLDWMasked256 [a] x y mask)
for {
- if v_0.Op != OpAMD64VMULPS512 {
+ if v_0.Op != OpAMD64VPSHLDW256 {
break
}
+ a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VMULPSMasked512)
+ v.reset(OpAMD64VPSHLDWMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPMULLD512 x y) mask)
- // result: (VPMULLDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPSLLW256 x y) mask)
+ // result: (VPSLLWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPMULLD512 {
+ if v_0.Op != OpAMD64VPSLLW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMULLDMasked512)
+ v.reset(OpAMD64VPSLLWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VFMSUBADD213PS512 x y z) mask)
- // result: (VFMSUBADD213PSMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPSHRDW256 [a] x y) mask)
+ // result: (VPSHRDWMasked256 [a] x y mask)
for {
- if v_0.Op != OpAMD64VFMSUBADD213PS512 {
+ if v_0.Op != OpAMD64VPSHRDW256 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
+ a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
+ x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VFMSUBADD213PSMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPSHRDWMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPOPCNTD512 x) mask)
- // result: (VPOPCNTDMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPSRAW256 x y) mask)
+ // result: (VPSRAWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPOPCNTD512 {
+ if v_0.Op != OpAMD64VPSRAW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPOPCNTDMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSRAWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPORD512 x y) mask)
- // result: (VPORDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPSRLW256 x y) mask)
+ // result: (VPSRLWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPORD512 {
+ if v_0.Op != OpAMD64VPSRLW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPORDMasked512)
+ v.reset(OpAMD64VPSRLWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPERMI2PS512 x y z) mask)
- // result: (VPERMI2PSMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPSHLDVW256 x y z) mask)
+ // result: (VPSHLDVWMasked256 x y z mask)
for {
- if v_0.Op != OpAMD64VPERMI2PS512 {
+ if v_0.Op != OpAMD64VPSHLDVW256 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPERMI2PSMasked512)
+ v.reset(OpAMD64VPSHLDVWMasked256)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPERMI2D512 x y z) mask)
- // result: (VPERMI2DMasked512 x y z mask)
+ // match: (VMOVDQU16Masked256 (VPSLLVW256 x y) mask)
+ // result: (VPSLLVWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMI2D512 {
+ if v_0.Op != OpAMD64VPSLLVW256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVWMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked256 (VPSHRDVW256 x y z) mask)
+ // result: (VPSHRDVWMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVW256 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPERMI2DMasked512)
+ v.reset(OpAMD64VPSHRDVWMasked256)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSHUFD512 [a] x) mask)
- // result: (VPSHUFDMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked256 (VPSRAVW256 x y) mask)
+ // result: (VPSRAVWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSHUFD512 {
+ if v_0.Op != OpAMD64VPSRAVW256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHUFDMasked512)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSRAVWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPERMPS512 x y) mask)
- // result: (VPERMPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPSRLVW256 x y) mask)
+ // result: (VPSRLVWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMPS512 {
+ if v_0.Op != OpAMD64VPSRLVW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMPSMasked512)
+ v.reset(OpAMD64VPSRLVWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPERMD512 x y) mask)
- // result: (VPERMDMasked512 x y mask)
+ // match: (VMOVDQU16Masked256 (VPSUBW256 x y) mask)
+ // result: (VPSUBWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMD512 {
+ if v_0.Op != OpAMD64VPSUBW256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMDMasked512)
+ v.reset(OpAMD64VPSUBWMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VRCP14PS512 x) mask)
- // result: (VRCP14PSMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPSUBSW256 x y) mask)
+ // result: (VPSUBSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VRCP14PS512 {
+ if v_0.Op != OpAMD64VPSUBSW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRCP14PSMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBSWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VRSQRT14PS512 x) mask)
- // result: (VRSQRT14PSMasked512 x mask)
+ // match: (VMOVDQU16Masked256 (VPSUBUSW256 x y) mask)
+ // result: (VPSUBUSWMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VRSQRT14PS512 {
+ if v_0.Op != OpAMD64VPSUBUSW256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRSQRT14PSMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBUSWMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPROLD512 [a] x) mask)
- // result: (VPROLDMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked256 (VPSLLW256const [a] x) mask)
+ // result: (VPSLLWMasked256const [a] x mask)
for {
- if v_0.Op != OpAMD64VPROLD512 {
+ if v_0.Op != OpAMD64VPSLLW256const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPROLDMasked512)
+ v.reset(OpAMD64VPSLLWMasked256const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPRORD512 [a] x) mask)
- // result: (VPRORDMasked512 [a] x mask)
+ // match: (VMOVDQU16Masked256 (VPSRAW256const [a] x) mask)
+ // result: (VPSRAWMasked256const [a] x mask)
for {
- if v_0.Op != OpAMD64VPRORD512 {
+ if v_0.Op != OpAMD64VPSRAW256const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPRORDMasked512)
+ v.reset(OpAMD64VPSRAWMasked256const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPROLVD512 x y) mask)
- // result: (VPROLVDMasked512 x y mask)
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU16Masked512(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU16Masked512 (VPABSW512 x) mask)
+ // result: (VPABSWMasked512 x mask)
for {
- if v_0.Op != OpAMD64VPROLVD512 {
+ if v_0.Op != OpAMD64VPABSW512 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPROLVDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPABSWMasked512)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPRORVD512 x y) mask)
- // result: (VPRORVDMasked512 x y mask)
+ // match: (VMOVDQU16Masked512 (VPADDW512 x y) mask)
+ // result: (VPADDWMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPRORVD512 {
+ if v_0.Op != OpAMD64VPADDW512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPRORVDMasked512)
+ v.reset(OpAMD64VPADDWMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VSCALEFPS512 x y) mask)
- // result: (VSCALEFPSMasked512 x y mask)
+ // match: (VMOVDQU16Masked512 (VPADDSW512 x y) mask)
+ // result: (VPADDSWMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VSCALEFPS512 {
+ if v_0.Op != OpAMD64VPADDSW512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VSCALEFPSMasked512)
+ v.reset(OpAMD64VPADDSWMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSHLDD512 [a] x y) mask)
- // result: (VPSHLDDMasked512 [a] x y mask)
+ // match: (VMOVDQU16Masked512 (VPADDUSW512 x y) mask)
+ // result: (VPADDUSWMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSHLDD512 {
+ if v_0.Op != OpAMD64VPADDUSW512 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHLDDMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPADDUSWMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSLLD512 x y) mask)
- // result: (VPSLLDMasked512 x y mask)
+ // match: (VMOVDQU16Masked512 (VPAVGW512 x y) mask)
+ // result: (VPAVGWMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSLLD512 {
+ if v_0.Op != OpAMD64VPAVGW512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLDMasked512)
+ v.reset(OpAMD64VPAVGWMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSHRDD512 [a] x y) mask)
- // result: (VPSHRDDMasked512 [a] x y mask)
+ // match: (VMOVDQU16Masked512 (VPBROADCASTW512 x) mask)
+ // result: (VPBROADCASTWMasked512 x mask)
for {
- if v_0.Op != OpAMD64VPSHRDD512 {
+ if v_0.Op != OpAMD64VPBROADCASTW512 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHRDDMasked512)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPBROADCASTWMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMOVSXWD512 x) mask)
+ // result: (VPMOVSXWDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSXWD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSXWDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMOVSXWQ512 x) mask)
+ // result: (VPMOVSXWQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSXWQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSXWQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMOVZXWD512 x) mask)
+ // result: (VPMOVZXWDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXWD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXWDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMOVZXWQ512 x) mask)
+ // result: (VPMOVZXWQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXWQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXWQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMADDWD512 x y) mask)
+ // result: (VPMADDWDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMADDWD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMADDWDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMADDUBSW512 x y) mask)
+ // result: (VPMADDUBSWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMADDUBSW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMADDUBSWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMAXSW512 x y) mask)
+ // result: (VPMAXSWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMAXUW512 x y) mask)
+ // result: (VPMAXUWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMINSW512 x y) mask)
+ // result: (VPMINSWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMINUW512 x y) mask)
+ // result: (VPMINUWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMULHW512 x y) mask)
+ // result: (VPMULHWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULHW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULHWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMULHUW512 x y) mask)
+ // result: (VPMULHUWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULHUW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULHUWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPMULLW512 x y) mask)
+ // result: (VPMULLWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPOPCNTW512 x) mask)
+ // result: (VPOPCNTWMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTW512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTWMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPERMI2W512 x y z) mask)
+ // result: (VPERMI2WMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2W512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2WMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSHUFHW512 [a] x) mask)
+ // result: (VPSHUFHWMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSHUFHW512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHUFHWMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPERMW512 x y) mask)
+ // result: (VPERMWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSHLDW512 [a] x y) mask)
+ // result: (VPSHLDWMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDW512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDWMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSLLW512 x y) mask)
+ // result: (VPSLLWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSHRDW512 [a] x y) mask)
+ // result: (VPSHRDWMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDW512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDWMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSRAW512 x y) mask)
+ // result: (VPSRAWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSRLW512 x y) mask)
+ // result: (VPSRLWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSHLDVW512 x y z) mask)
+ // result: (VPSHLDVWMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVW512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVWMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSLLVW512 x y) mask)
+ // result: (VPSLLVWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSHRDVW512 x y z) mask)
+ // result: (VPSHRDVWMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVW512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVWMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSRAVW512 x y) mask)
+ // result: (VPSRAVWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSRLVW512 x y) mask)
+ // result: (VPSRLVWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSUBW512 x y) mask)
+ // result: (VPSUBWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSUBSW512 x y) mask)
+ // result: (VPSUBSWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBSW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBSWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSUBUSW512 x y) mask)
+ // result: (VPSUBUSWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBUSW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBUSWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSLLW512const [a] x) mask)
+ // result: (VPSLLWMasked512const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLW512const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLWMasked512const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU16Masked512 (VPSRAW512const [a] x) mask)
+ // result: (VPSRAWMasked512const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAW512const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAWMasked512const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU32Masked128(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU32Masked128 (VPABSD128 x) mask)
+ // result: (VPABSDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPDPBUSD128 x y z) mask)
+ // result: (VPDPBUSDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPDPBUSDS128 x y z) mask)
+ // result: (VPDPBUSDSMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSDS128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDSMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VADDPS128 x y) mask)
+ // result: (VADDPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPADDD128 x y) mask)
+ // result: (VPADDDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPADDDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VBROADCASTSS128 x) mask)
+ // result: (VBROADCASTSSMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VBROADCASTSS128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VBROADCASTSSMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPBROADCASTD128 x) mask)
+ // result: (VPBROADCASTDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VRNDSCALEPS128 [a] x) mask)
+ // result: (VRNDSCALEPSMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPS128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPSMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VREDUCEPS128 [a] x) mask)
+ // result: (VREDUCEPSMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPS128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPSMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVDB128 x) mask)
+ // result: (VPMOVDBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVDB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVDBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVSDB128 x) mask)
+ // result: (VPMOVSDBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSDB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSDBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVDW128 x) mask)
+ // result: (VPMOVDWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVDW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVDWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVSDW128 x) mask)
+ // result: (VPMOVSDWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSDW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSDWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPACKSSDW128 x y) mask)
+ // result: (VPACKSSDWMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKSSDW128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKSSDWMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VCVTTPS2DQ128 x) mask)
+ // result: (VCVTTPS2DQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTTPS2DQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTTPS2DQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVSXDQ128 x) mask)
+ // result: (VPMOVSXDQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSXDQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSXDQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVUSDB128 x) mask)
+ // result: (VPMOVUSDBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSDB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSDBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVUSDW128 x) mask)
+ // result: (VPMOVUSDWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSDW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSDWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPACKUSDW128 x y) mask)
+ // result: (VPACKUSDWMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKUSDW128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKUSDWMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VCVTPS2UDQ128 x) mask)
+ // result: (VCVTPS2UDQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTPS2UDQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTPS2UDQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMOVZXDQ128 x) mask)
+ // result: (VPMOVZXDQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXDQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXDQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VDIVPS128 x y) mask)
+ // result: (VDIVPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPLZCNTD128 x) mask)
+ // result: (VPLZCNTDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VMAXPS128 x y) mask)
+ // result: (VMAXPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMAXSD128 x y) mask)
+ // result: (VPMAXSDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMAXUD128 x y) mask)
+ // result: (VPMAXUDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VMINPS128 x y) mask)
+ // result: (VMINPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMINSD128 x y) mask)
+ // result: (VPMINSDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMINUD128 x y) mask)
+ // result: (VPMINUDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VFMADD213PS128 x y z) mask)
+ // result: (VFMADD213PSMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PS128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADD213PSMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VFMADDSUB213PS128 x y z) mask)
+ // result: (VFMADDSUB213PSMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADDSUB213PS128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PSMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VMULPS128 x y) mask)
+ // result: (VMULPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMULPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPMULLD128 x y) mask)
+ // result: (VPMULLDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VFMSUBADD213PS128 x y z) mask)
+ // result: (VFMSUBADD213PSMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PS128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PSMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPOPCNTD128 x) mask)
+ // result: (VPOPCNTDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPERMI2PS128 x y z) mask)
+ // result: (VPERMI2PSMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PS128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PSMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPERMI2D128 x y z) mask)
+ // result: (VPERMI2DMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2D128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2DMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSHUFD128 [a] x) mask)
+ // result: (VPSHUFDMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSHUFD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHUFDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPROLD128 [a] x) mask)
+ // result: (VPROLDMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPRORD128 [a] x) mask)
+ // result: (VPRORDMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPROLVD128 x y) mask)
+ // result: (VPROLVDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPRORVD128 x y) mask)
+ // result: (VPRORVDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VSCALEFPS128 x y) mask)
+ // result: (VSCALEFPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSHLDD128 [a] x y) mask)
+ // result: (VPSHLDDMasked128 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSLLD128 x y) mask)
+ // result: (VPSLLDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSHRDD128 [a] x y) mask)
+ // result: (VPSHRDDMasked128 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSRAD128 x y) mask)
+ // result: (VPSRADMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSRLD128 x y) mask)
+ // result: (VPSRLDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSHLDVD128 x y z) mask)
+ // result: (VPSHLDVDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSLLVD128 x y) mask)
+ // result: (VPSLLVDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSHRDVD128 x y z) mask)
+ // result: (VPSHRDVDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSRAVD128 x y) mask)
+ // result: (VPSRAVDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSRLVD128 x y) mask)
+ // result: (VPSRLVDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VSQRTPS128 x) mask)
+ // result: (VSQRTPSMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VSQRTPS128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSQRTPSMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VSUBPS128 x y) mask)
+ // result: (VSUBPSMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSUBPS128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSUBPSMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSUBD128 x y) mask)
+ // result: (VPSUBDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSLLD128const [a] x) mask)
+ // result: (VPSLLDMasked128const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD128const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked128const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked128 (VPSRAD128const [a] x) mask)
+ // result: (VPSRADMasked128const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAD128const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked128const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU32Masked256(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU32Masked256 (VPABSD256 x) mask)
+ // result: (VPABSDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPDPBUSD256 x y z) mask)
+ // result: (VPDPBUSDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPDPBUSDS256 x y z) mask)
+ // result: (VPDPBUSDSMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSDS256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDSMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VADDPS256 x y) mask)
+ // result: (VADDPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPADDD256 x y) mask)
+ // result: (VPADDDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPADDDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VBROADCASTSS256 x) mask)
+ // result: (VBROADCASTSSMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VBROADCASTSS256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VBROADCASTSSMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPBROADCASTD256 x) mask)
+ // result: (VPBROADCASTDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VRNDSCALEPS256 [a] x) mask)
+ // result: (VRNDSCALEPSMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPS256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPSMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VREDUCEPS256 [a] x) mask)
+ // result: (VREDUCEPSMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPS256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPSMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMOVDW256 x) mask)
+ // result: (VPMOVDWMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVDW256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVDWMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMOVSDW256 x) mask)
+ // result: (VPMOVSDWMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSDW256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSDWMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPACKSSDW256 x y) mask)
+ // result: (VPACKSSDWMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKSSDW256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKSSDWMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VCVTTPS2DQ256 x) mask)
+ // result: (VCVTTPS2DQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTTPS2DQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTTPS2DQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMOVSXDQ256 x) mask)
+ // result: (VPMOVSXDQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSXDQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSXDQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMOVUSDW256 x) mask)
+ // result: (VPMOVUSDWMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSDW256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSDWMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPACKUSDW256 x y) mask)
+ // result: (VPACKUSDWMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKUSDW256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKUSDWMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VCVTPS2UDQ256 x) mask)
+ // result: (VCVTPS2UDQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTPS2UDQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTPS2UDQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMOVZXDQ256 x) mask)
+ // result: (VPMOVZXDQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXDQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXDQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VDIVPS256 x y) mask)
+ // result: (VDIVPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPLZCNTD256 x) mask)
+ // result: (VPLZCNTDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VMAXPS256 x y) mask)
+ // result: (VMAXPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMAXSD256 x y) mask)
+ // result: (VPMAXSDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMAXUD256 x y) mask)
+ // result: (VPMAXUDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VMINPS256 x y) mask)
+ // result: (VMINPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMINSD256 x y) mask)
+ // result: (VPMINSDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMINUD256 x y) mask)
+ // result: (VPMINUDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VFMADD213PS256 x y z) mask)
+ // result: (VFMADD213PSMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PS256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADD213PSMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VFMADDSUB213PS256 x y z) mask)
+ // result: (VFMADDSUB213PSMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADDSUB213PS256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PSMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VMULPS256 x y) mask)
+ // result: (VMULPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMULPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPMULLD256 x y) mask)
+ // result: (VPMULLDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VFMSUBADD213PS256 x y z) mask)
+ // result: (VFMSUBADD213PSMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PS256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PSMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPOPCNTD256 x) mask)
+ // result: (VPOPCNTDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPERMI2PS256 x y z) mask)
+ // result: (VPERMI2PSMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PS256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PSMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPERMI2D256 x y z) mask)
+ // result: (VPERMI2DMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2D256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2DMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSHUFD256 [a] x) mask)
+ // result: (VPSHUFDMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSHUFD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHUFDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPERMPS256 x y) mask)
+ // result: (VPERMPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPERMD256 x y) mask)
+ // result: (VPERMDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPROLD256 [a] x) mask)
+ // result: (VPROLDMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPRORD256 [a] x) mask)
+ // result: (VPRORDMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPROLVD256 x y) mask)
+ // result: (VPROLVDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPRORVD256 x y) mask)
+ // result: (VPRORVDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VSCALEFPS256 x y) mask)
+ // result: (VSCALEFPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSHLDD256 [a] x y) mask)
+ // result: (VPSHLDDMasked256 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSLLD256 x y) mask)
+ // result: (VPSLLDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSHRDD256 [a] x y) mask)
+ // result: (VPSHRDDMasked256 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSRAD256 x y) mask)
+ // result: (VPSRADMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSRLD256 x y) mask)
+ // result: (VPSRLDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSHLDVD256 x y z) mask)
+ // result: (VPSHLDVDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSLLVD256 x y) mask)
+ // result: (VPSLLVDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSHRDVD256 x y z) mask)
+ // result: (VPSHRDVDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSRAVD256 x y) mask)
+ // result: (VPSRAVDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSRLVD256 x y) mask)
+ // result: (VPSRLVDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VSQRTPS256 x) mask)
+ // result: (VSQRTPSMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VSQRTPS256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSQRTPSMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VSUBPS256 x y) mask)
+ // result: (VSUBPSMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSUBPS256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSUBPSMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSUBD256 x y) mask)
+ // result: (VPSUBDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSLLD256const [a] x) mask)
+ // result: (VPSLLDMasked256const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD256const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked256const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked256 (VPSRAD256const [a] x) mask)
+ // result: (VPSRADMasked256const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAD256const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked256const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU32Masked512(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU32Masked512 (VPABSD512 x) mask)
+ // result: (VPABSDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPDPBUSD512 x y z) mask)
+ // result: (VPDPBUSDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPDPBUSDS512 x y z) mask)
+ // result: (VPDPBUSDSMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPDPBUSDS512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPDPBUSDSMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VADDPS512 x y) mask)
+ // result: (VADDPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPADDD512 x y) mask)
+ // result: (VPADDDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPADDDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPANDD512 x y) mask)
+ // result: (VPANDDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPANDD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPANDDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPANDND512 x y) mask)
+ // result: (VPANDNDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPANDND512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPANDNDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VBROADCASTSS512 x) mask)
+ // result: (VBROADCASTSSMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VBROADCASTSS512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VBROADCASTSSMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPBROADCASTD512 x) mask)
+ // result: (VPBROADCASTDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VRNDSCALEPS512 [a] x) mask)
+ // result: (VRNDSCALEPSMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPS512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPSMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VREDUCEPS512 [a] x) mask)
+ // result: (VREDUCEPSMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPS512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPSMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPACKSSDW512 x y) mask)
+ // result: (VPACKSSDWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKSSDW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKSSDWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VCVTTPS2DQ512 x) mask)
+ // result: (VCVTTPS2DQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTTPS2DQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTTPS2DQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMOVSXDQ512 x) mask)
+ // result: (VPMOVSXDQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSXDQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSXDQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPACKUSDW512 x y) mask)
+ // result: (VPACKUSDWMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPACKUSDW512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPACKUSDWMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VCVTPS2UDQ512 x) mask)
+ // result: (VCVTPS2UDQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VCVTPS2UDQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VCVTPS2UDQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMOVZXDQ512 x) mask)
+ // result: (VPMOVZXDQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVZXDQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVZXDQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VDIVPS512 x y) mask)
+ // result: (VDIVPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPLZCNTD512 x) mask)
+ // result: (VPLZCNTDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VMAXPS512 x y) mask)
+ // result: (VMAXPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMAXSD512 x y) mask)
+ // result: (VPMAXSDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMAXUD512 x y) mask)
+ // result: (VPMAXUDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VMINPS512 x y) mask)
+ // result: (VMINPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMINSD512 x y) mask)
+ // result: (VPMINSDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMINUD512 x y) mask)
+ // result: (VPMINUDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VFMADD213PS512 x y z) mask)
+ // result: (VFMADD213PSMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PS512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADD213PSMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VFMADDSUB213PS512 x y z) mask)
+ // result: (VFMADDSUB213PSMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADDSUB213PS512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PSMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VMULPS512 x y) mask)
+ // result: (VMULPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMULPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPMULLD512 x y) mask)
+ // result: (VPMULLDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VFMSUBADD213PS512 x y z) mask)
+ // result: (VFMSUBADD213PSMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PS512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PSMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPOPCNTD512 x) mask)
+ // result: (VPOPCNTDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPORD512 x y) mask)
+ // result: (VPORDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPORD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPORDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPERMI2PS512 x y z) mask)
+ // result: (VPERMI2PSMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PS512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PSMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPERMI2D512 x y z) mask)
+ // result: (VPERMI2DMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2D512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2DMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSHUFD512 [a] x) mask)
+ // result: (VPSHUFDMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSHUFD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHUFDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPERMPS512 x y) mask)
+ // result: (VPERMPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPERMD512 x y) mask)
+ // result: (VPERMDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VRCP14PS512 x) mask)
+ // result: (VRCP14PSMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VRCP14PS512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRCP14PSMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VRSQRT14PS512 x) mask)
+ // result: (VRSQRT14PSMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VRSQRT14PS512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRSQRT14PSMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPROLD512 [a] x) mask)
+ // result: (VPROLDMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPRORD512 [a] x) mask)
+ // result: (VPRORDMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPROLVD512 x y) mask)
+ // result: (VPROLVDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPRORVD512 x y) mask)
+ // result: (VPRORVDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VSCALEFPS512 x y) mask)
+ // result: (VSCALEFPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSHLDD512 [a] x y) mask)
+ // result: (VPSHLDDMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSLLD512 x y) mask)
+ // result: (VPSLLDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSHRDD512 [a] x y) mask)
+ // result: (VPSHRDDMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
return true
}
// match: (VMOVDQU32Masked512 (VPSRAD512 x y) mask)
// result: (VPSRADMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAD512 {
+ if v_0.Op != OpAMD64VPSRAD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSRLD512 x y) mask)
+ // result: (VPSRLDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSHLDVD512 x y z) mask)
+ // result: (VPSHLDVDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSLLVD512 x y) mask)
+ // result: (VPSLLVDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSHRDVD512 x y z) mask)
+ // result: (VPSHRDVDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSRAVD512 x y) mask)
+ // result: (VPSRAVDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSRLVD512 x y) mask)
+ // result: (VPSRLVDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VSQRTPS512 x) mask)
+ // result: (VSQRTPSMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VSQRTPS512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSQRTPSMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VSUBPS512 x y) mask)
+ // result: (VSUBPSMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSUBPS512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSUBPSMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSUBD512 x y) mask)
+ // result: (VPSUBDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPXORD512 x y) mask)
+ // result: (VPXORDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPXORD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPXORDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSLLD512const [a] x) mask)
+ // result: (VPSLLDMasked512const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLD512const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLDMasked512const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU32Masked512 (VPSRAD512const [a] x) mask)
+ // result: (VPSRADMasked512const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAD512const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRADMasked512const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU64Masked128(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU64Masked128 (VPABSQ128 x) mask)
+ // result: (VPABSQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VADDPD128 x y) mask)
+ // result: (VADDPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPADDQ128 x y) mask)
+ // result: (VPADDQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPADDQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPBROADCASTQ128 x) mask)
+ // result: (VPBROADCASTQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VRNDSCALEPD128 [a] x) mask)
+ // result: (VRNDSCALEPDMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VREDUCEPD128 [a] x) mask)
+ // result: (VREDUCEPDMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPD128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPDMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVQB128 x) mask)
+ // result: (VPMOVQBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVQB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVQBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVSQB128 x) mask)
+ // result: (VPMOVSQBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSQB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSQBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVQW128 x) mask)
+ // result: (VPMOVQWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVQW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVQWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVSQW128 x) mask)
+ // result: (VPMOVSQWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSQW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSQWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVQD128 x) mask)
+ // result: (VPMOVQDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVQD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVQDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVSQD128 x) mask)
+ // result: (VPMOVSQDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSQD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSQDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVUSQB128 x) mask)
+ // result: (VPMOVUSQBMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSQB128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSQBMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVUSQW128 x) mask)
+ // result: (VPMOVUSQWMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSQW128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSQWMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMOVUSQD128 x) mask)
+ // result: (VPMOVUSQDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSQD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSQDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VDIVPD128 x y) mask)
+ // result: (VDIVPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPLZCNTQ128 x) mask)
+ // result: (VPLZCNTQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VMAXPD128 x y) mask)
+ // result: (VMAXPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMAXSQ128 x y) mask)
+ // result: (VPMAXSQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMAXUQ128 x y) mask)
+ // result: (VPMAXUQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VMINPD128 x y) mask)
+ // result: (VMINPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMINSQ128 x y) mask)
+ // result: (VPMINSQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMINUQ128 x y) mask)
+ // result: (VPMINUQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VFMADD213PD128 x y z) mask)
+ // result: (VFMADD213PDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADD213PDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VFMADDSUB213PD128 x y z) mask)
+ // result: (VFMADDSUB213PDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADDSUB213PD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VMULPD128 x y) mask)
+ // result: (VMULPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMULPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPMULLQ128 x y) mask)
+ // result: (VPMULLQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VFMSUBADD213PD128 x y z) mask)
+ // result: (VFMSUBADD213PDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPOPCNTQ128 x) mask)
+ // result: (VPOPCNTQMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTQ128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTQMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPERMI2PD128 x y z) mask)
+ // result: (VPERMI2PDMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PD128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PDMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPERMI2Q128 x y z) mask)
+ // result: (VPERMI2QMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2Q128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2QMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VRCP14PD128 x) mask)
+ // result: (VRCP14PDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VRCP14PD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRCP14PDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VRSQRT14PD128 x) mask)
+ // result: (VRSQRT14PDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VRSQRT14PD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRSQRT14PDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPROLQ128 [a] x) mask)
+ // result: (VPROLQMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLQ128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLQMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPRORQ128 [a] x) mask)
+ // result: (VPRORQMasked128 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORQ128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORQMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPROLVQ128 x y) mask)
+ // result: (VPROLVQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPRORVQ128 x y) mask)
+ // result: (VPRORVQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VSCALEFPD128 x y) mask)
+ // result: (VSCALEFPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSHLDQ128 [a] x y) mask)
+ // result: (VPSHLDQMasked128 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDQ128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDQMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSLLQ128 x y) mask)
+ // result: (VPSLLQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSHRDQ128 [a] x y) mask)
+ // result: (VPSHRDQMasked128 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDQ128 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDQMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSRAQ128 x y) mask)
+ // result: (VPSRAQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSRLQ128 x y) mask)
+ // result: (VPSRLQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSHLDVQ128 x y z) mask)
+ // result: (VPSHLDVQMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVQ128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVQMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSLLVQ128 x y) mask)
+ // result: (VPSLLVQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSHRDVQ128 x y z) mask)
+ // result: (VPSHRDVQMasked128 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVQ128 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVQMasked128)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSRAVQ128 x y) mask)
+ // result: (VPSRAVQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSRLVQ128 x y) mask)
+ // result: (VPSRLVQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VSQRTPD128 x) mask)
+ // result: (VSQRTPDMasked128 x mask)
+ for {
+ if v_0.Op != OpAMD64VSQRTPD128 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSQRTPDMasked128)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VSUBPD128 x y) mask)
+ // result: (VSUBPDMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSUBPD128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSUBPDMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSUBQ128 x y) mask)
+ // result: (VPSUBQMasked128 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBQ128 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBQMasked128)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSLLQ128const [a] x) mask)
+ // result: (VPSLLQMasked128const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLQ128const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLQMasked128const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked128 (VPSRAQ128const [a] x) mask)
+ // result: (VPSRAQMasked128const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAQ128const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAQMasked128const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU64Masked256(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU64Masked256 (VPABSQ256 x) mask)
+ // result: (VPABSQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VADDPD256 x y) mask)
+ // result: (VADDPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPADDQ256 x y) mask)
+ // result: (VPADDQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPADDQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VBROADCASTSD256 x) mask)
+ // result: (VBROADCASTSDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VBROADCASTSD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VBROADCASTSDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPBROADCASTQ256 x) mask)
+ // result: (VPBROADCASTQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VRNDSCALEPD256 [a] x) mask)
+ // result: (VRNDSCALEPDMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VREDUCEPD256 [a] x) mask)
+ // result: (VREDUCEPDMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPD256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPDMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMOVQD256 x) mask)
+ // result: (VPMOVQDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVQD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVQDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMOVSQD256 x) mask)
+ // result: (VPMOVSQDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVSQD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVSQDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMOVUSQD256 x) mask)
+ // result: (VPMOVUSQDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPMOVUSQD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMOVUSQDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VDIVPD256 x y) mask)
+ // result: (VDIVPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPLZCNTQ256 x) mask)
+ // result: (VPLZCNTQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VMAXPD256 x y) mask)
+ // result: (VMAXPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMAXSQ256 x y) mask)
+ // result: (VPMAXSQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMAXUQ256 x y) mask)
+ // result: (VPMAXUQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VMINPD256 x y) mask)
+ // result: (VMINPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMINSQ256 x y) mask)
+ // result: (VPMINSQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMINUQ256 x y) mask)
+ // result: (VPMINUQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VFMADD213PD256 x y z) mask)
+ // result: (VFMADD213PDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADD213PDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VFMADDSUB213PD256 x y z) mask)
+ // result: (VFMADDSUB213PDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADDSUB213PD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VMULPD256 x y) mask)
+ // result: (VMULPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMULPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPMULLQ256 x y) mask)
+ // result: (VPMULLQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VFMSUBADD213PD256 x y z) mask)
+ // result: (VFMSUBADD213PDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPOPCNTQ256 x) mask)
+ // result: (VPOPCNTQMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTQ256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTQMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPERMI2PD256 x y z) mask)
+ // result: (VPERMI2PDMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PD256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PDMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPERMI2Q256 x y z) mask)
+ // result: (VPERMI2QMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2Q256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2QMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPERMPD256 x y) mask)
+ // result: (VPERMPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPERMQ256 x y) mask)
+ // result: (VPERMQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VRCP14PD256 x) mask)
+ // result: (VRCP14PDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VRCP14PD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRCP14PDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VRSQRT14PD256 x) mask)
+ // result: (VRSQRT14PDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VRSQRT14PD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRSQRT14PDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPROLQ256 [a] x) mask)
+ // result: (VPROLQMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLQ256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLQMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPRORQ256 [a] x) mask)
+ // result: (VPRORQMasked256 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORQ256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORQMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPROLVQ256 x y) mask)
+ // result: (VPROLVQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPRORVQ256 x y) mask)
+ // result: (VPRORVQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VSCALEFPD256 x y) mask)
+ // result: (VSCALEFPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSHLDQ256 [a] x y) mask)
+ // result: (VPSHLDQMasked256 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDQ256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDQMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSLLQ256 x y) mask)
+ // result: (VPSLLQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSHRDQ256 [a] x y) mask)
+ // result: (VPSHRDQMasked256 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDQ256 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDQMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSRAQ256 x y) mask)
+ // result: (VPSRAQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSRLQ256 x y) mask)
+ // result: (VPSRLQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSHLDVQ256 x y z) mask)
+ // result: (VPSHLDVQMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVQ256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVQMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSLLVQ256 x y) mask)
+ // result: (VPSLLVQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSHRDVQ256 x y z) mask)
+ // result: (VPSHRDVQMasked256 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDVQ256 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDVQMasked256)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSRAVQ256 x y) mask)
+ // result: (VPSRAVQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAVQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAVQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSRLVQ256 x y) mask)
+ // result: (VPSRLVQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLVQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLVQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VSQRTPD256 x) mask)
+ // result: (VSQRTPDMasked256 x mask)
+ for {
+ if v_0.Op != OpAMD64VSQRTPD256 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSQRTPDMasked256)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VSUBPD256 x y) mask)
+ // result: (VSUBPDMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSUBPD256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSUBPDMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSUBQ256 x y) mask)
+ // result: (VPSUBQMasked256 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSUBQ256 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSUBQMasked256)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSLLQ256const [a] x) mask)
+ // result: (VPSLLQMasked256const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLQ256const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLQMasked256const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked256 (VPSRAQ256const [a] x) mask)
+ // result: (VPSRAQMasked256const [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAQ256const {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAQMasked256const)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU64Masked512(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU64Masked512 (VPABSQ512 x) mask)
+ // result: (VPABSQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPABSQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPABSQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VADDPD512 x y) mask)
+ // result: (VADDPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VADDPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VADDPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPADDQ512 x y) mask)
+ // result: (VPADDQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPADDQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRADMasked512)
+ v.reset(OpAMD64VPADDQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSRLD512 x y) mask)
- // result: (VPSRLDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VPANDQ512 x y) mask)
+ // result: (VPANDQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLD512 {
+ if v_0.Op != OpAMD64VPANDQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLDMasked512)
+ v.reset(OpAMD64VPANDQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSHLDVD512 x y z) mask)
- // result: (VPSHLDVDMasked512 x y z mask)
+ // match: (VMOVDQU64Masked512 (VPANDNQ512 x y) mask)
+ // result: (VPANDNQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSHLDVD512 {
+ if v_0.Op != OpAMD64VPANDNQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPANDNQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VBROADCASTSD512 x) mask)
+ // result: (VBROADCASTSDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VBROADCASTSD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VBROADCASTSDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPBROADCASTQ512 x) mask)
+ // result: (VPBROADCASTQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPBROADCASTQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPBROADCASTQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VRNDSCALEPD512 [a] x) mask)
+ // result: (VRNDSCALEPDMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VRNDSCALEPD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRNDSCALEPDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VREDUCEPD512 [a] x) mask)
+ // result: (VREDUCEPDMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VREDUCEPD512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VREDUCEPDMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VDIVPD512 x y) mask)
+ // result: (VDIVPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VDIVPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VDIVPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPLZCNTQ512 x) mask)
+ // result: (VPLZCNTQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPLZCNTQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPLZCNTQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VMAXPD512 x y) mask)
+ // result: (VMAXPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMAXPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMAXPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPMAXSQ512 x y) mask)
+ // result: (VPMAXSQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXSQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXSQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPMAXUQ512 x y) mask)
+ // result: (VPMAXUQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMAXUQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMAXUQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VMINPD512 x y) mask)
+ // result: (VMINPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMINPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VMINPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPMINSQ512 x y) mask)
+ // result: (VPMINSQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINSQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINSQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPMINUQ512 x y) mask)
+ // result: (VPMINUQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMINUQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMINUQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VFMADD213PD512 x y z) mask)
+ // result: (VFMADD213PDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMADD213PD512 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPSHLDVDMasked512)
+ v.reset(OpAMD64VFMADD213PDMasked512)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSLLVD512 x y) mask)
- // result: (VPSLLVDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VFMADDSUB213PD512 x y z) mask)
+ // result: (VFMADDSUB213PDMasked512 x y z mask)
for {
- if v_0.Op != OpAMD64VPSLLVD512 {
+ if v_0.Op != OpAMD64VFMADDSUB213PD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMADDSUB213PDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VMULPD512 x y) mask)
+ // result: (VMULPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VMULPD512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLVDMasked512)
+ v.reset(OpAMD64VMULPDMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSHRDVD512 x y z) mask)
- // result: (VPSHRDVDMasked512 x y z mask)
+ // match: (VMOVDQU64Masked512 (VPMULLQ512 x y) mask)
+ // result: (VPMULLQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPMULLQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPMULLQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VFMSUBADD213PD512 x y z) mask)
+ // result: (VFMSUBADD213PDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VFMSUBADD213PD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VFMSUBADD213PDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPOPCNTQ512 x) mask)
+ // result: (VPOPCNTQMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VPOPCNTQ512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPOPCNTQMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPORQ512 x y) mask)
+ // result: (VPORQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPORQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPORQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPERMI2PD512 x y z) mask)
+ // result: (VPERMI2PDMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2PD512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2PDMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPERMI2Q512 x y z) mask)
+ // result: (VPERMI2QMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPERMI2Q512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPERMI2QMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPERMPD512 x y) mask)
+ // result: (VPERMPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPERMQ512 x y) mask)
+ // result: (VPERMQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPERMQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPERMQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VRCP14PD512 x) mask)
+ // result: (VRCP14PDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VRCP14PD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRCP14PDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VRSQRT14PD512 x) mask)
+ // result: (VRSQRT14PDMasked512 x mask)
+ for {
+ if v_0.Op != OpAMD64VRSQRT14PD512 {
+ break
+ }
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VRSQRT14PDMasked512)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPROLQ512 [a] x) mask)
+ // result: (VPROLQMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPROLQ512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLQMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPRORQ512 [a] x) mask)
+ // result: (VPRORQMasked512 [a] x mask)
+ for {
+ if v_0.Op != OpAMD64VPRORQ512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORQMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg2(x, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPROLVQ512 x y) mask)
+ // result: (VPROLVQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPROLVQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPROLVQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPRORVQ512 x y) mask)
+ // result: (VPRORVQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPRORVQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPRORVQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VSCALEFPD512 x y) mask)
+ // result: (VSCALEFPDMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VSCALEFPD512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VSCALEFPDMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSHLDQ512 [a] x y) mask)
+ // result: (VPSHLDQMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDQ512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDQMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSLLQ512 x y) mask)
+ // result: (VPSLLQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSHRDQ512 [a] x y) mask)
+ // result: (VPSHRDQMasked512 [a] x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSHRDQ512 {
+ break
+ }
+ a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSHRDQMasked512)
+ v.AuxInt = uint8ToAuxInt(a)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSRAQ512 x y) mask)
+ // result: (VPSRAQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRAQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRAQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSRLQ512 x y) mask)
+ // result: (VPSRLQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSRLQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSRLQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSHLDVQ512 x y z) mask)
+ // result: (VPSHLDVQMasked512 x y z mask)
+ for {
+ if v_0.Op != OpAMD64VPSHLDVQ512 {
+ break
+ }
+ z := v_0.Args[2]
+ x := v_0.Args[0]
+ y := v_0.Args[1]
+ mask := v_1
+ v.reset(OpAMD64VPSHLDVQMasked512)
+ v.AddArg4(x, y, z, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSLLVQ512 x y) mask)
+ // result: (VPSLLVQMasked512 x y mask)
+ for {
+ if v_0.Op != OpAMD64VPSLLVQ512 {
+ break
+ }
+ y := v_0.Args[1]
+ x := v_0.Args[0]
+ mask := v_1
+ v.reset(OpAMD64VPSLLVQMasked512)
+ v.AddArg3(x, y, mask)
+ return true
+ }
+ // match: (VMOVDQU64Masked512 (VPSHRDVQ512 x y z) mask)
+ // result: (VPSHRDVQMasked512 x y z mask)
for {
- if v_0.Op != OpAMD64VPSHRDVD512 {
+ if v_0.Op != OpAMD64VPSHRDVQ512 {
break
}
z := v_0.Args[2]
x := v_0.Args[0]
y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPSHRDVDMasked512)
+ v.reset(OpAMD64VPSHRDVQMasked512)
v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSRAVD512 x y) mask)
- // result: (VPSRAVDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VPSRAVQ512 x y) mask)
+ // result: (VPSRAVQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAVD512 {
+ if v_0.Op != OpAMD64VPSRAVQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAVDMasked512)
+ v.reset(OpAMD64VPSRAVQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSRLVD512 x y) mask)
- // result: (VPSRLVDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VPSRLVQ512 x y) mask)
+ // result: (VPSRLVQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLVD512 {
+ if v_0.Op != OpAMD64VPSRLVQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLVDMasked512)
+ v.reset(OpAMD64VPSRLVQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VSQRTPS512 x) mask)
- // result: (VSQRTPSMasked512 x mask)
+ // match: (VMOVDQU64Masked512 (VSQRTPD512 x) mask)
+ // result: (VSQRTPDMasked512 x mask)
for {
- if v_0.Op != OpAMD64VSQRTPS512 {
+ if v_0.Op != OpAMD64VSQRTPD512 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VSQRTPSMasked512)
+ v.reset(OpAMD64VSQRTPDMasked512)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VSUBPS512 x y) mask)
- // result: (VSUBPSMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VSUBPD512 x y) mask)
+ // result: (VSUBPDMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VSUBPS512 {
+ if v_0.Op != OpAMD64VSUBPD512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VSUBPSMasked512)
+ v.reset(OpAMD64VSUBPDMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSUBD512 x y) mask)
- // result: (VPSUBDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VPSUBQ512 x y) mask)
+ // result: (VPSUBQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPSUBD512 {
+ if v_0.Op != OpAMD64VPSUBQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSUBDMasked512)
+ v.reset(OpAMD64VPSUBQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPXORD512 x y) mask)
- // result: (VPXORDMasked512 x y mask)
+ // match: (VMOVDQU64Masked512 (VPXORQ512 x y) mask)
+ // result: (VPXORQMasked512 x y mask)
for {
- if v_0.Op != OpAMD64VPXORD512 {
+ if v_0.Op != OpAMD64VPXORQ512 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPXORDMasked512)
+ v.reset(OpAMD64VPXORQMasked512)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSLLD512const [a] x) mask)
- // result: (VPSLLDMasked512const [a] x mask)
+ // match: (VMOVDQU64Masked512 (VPSLLQ512const [a] x) mask)
+ // result: (VPSLLQMasked512const [a] x mask)
for {
- if v_0.Op != OpAMD64VPSLLD512const {
+ if v_0.Op != OpAMD64VPSLLQ512const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLDMasked512const)
+ v.reset(OpAMD64VPSLLQMasked512const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSRLD512const [a] x) mask)
- // result: (VPSRLDMasked512const [a] x mask)
+ // match: (VMOVDQU64Masked512 (VPSRAQ512const [a] x) mask)
+ // result: (VPSRAQMasked512const [a] x mask)
for {
- if v_0.Op != OpAMD64VPSRLD512const {
+ if v_0.Op != OpAMD64VPSRAQ512const {
break
}
a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLDMasked512const)
+ v.reset(OpAMD64VPSRAQMasked512const)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU32Masked512 (VPSRAD512const [a] x) mask)
- // result: (VPSRADMasked512const [a] x mask)
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU8Masked128(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU8Masked128 (VPABSB128 x) mask)
+ // result: (VPABSBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPSRAD512const {
+ if v_0.Op != OpAMD64VPABSB128 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRADMasked512const)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPABSBMasked128)
v.AddArg2(x, mask)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64VMOVDQU64Masked512(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (VMOVDQU64Masked512 (VPABSQ512 x) mask)
- // result: (VPABSQMasked512 x mask)
+ // match: (VMOVDQU8Masked128 (VPADDB128 x y) mask)
+ // result: (VPADDBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPABSQ512 {
+ if v_0.Op != OpAMD64VPADDB128 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPABSQMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPADDBMasked128)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VADDPD512 x y) mask)
- // result: (VADDPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPADDSB128 x y) mask)
+ // result: (VPADDSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VADDPD512 {
+ if v_0.Op != OpAMD64VPADDSB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VADDPDMasked512)
+ v.reset(OpAMD64VPADDSBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPADDQ512 x y) mask)
- // result: (VPADDQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPADDUSB128 x y) mask)
+ // result: (VPADDUSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPADDQ512 {
+ if v_0.Op != OpAMD64VPADDUSB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPADDQMasked512)
+ v.reset(OpAMD64VPADDUSBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPANDQ512 x y) mask)
- // result: (VPANDQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPAVGB128 x y) mask)
+ // result: (VPAVGBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPANDQ512 {
+ if v_0.Op != OpAMD64VPAVGB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPANDQMasked512)
+ v.reset(OpAMD64VPAVGBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPANDNQ512 x y) mask)
- // result: (VPANDNQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPBROADCASTB128 x) mask)
+ // result: (VPBROADCASTBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPANDNQ512 {
+ if v_0.Op != OpAMD64VPBROADCASTB128 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPANDNQMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPBROADCASTBMasked128)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VBROADCASTSD512 x) mask)
- // result: (VBROADCASTSDMasked512 x mask)
+ // match: (VMOVDQU8Masked128 (VPMOVSXBW128 x) mask)
+ // result: (VPMOVSXBWMasked128 x mask)
for {
- if v_0.Op != OpAMD64VBROADCASTSD512 {
+ if v_0.Op != OpAMD64VPMOVSXBW128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VBROADCASTSDMasked512)
+ v.reset(OpAMD64VPMOVSXBWMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPBROADCASTQ512 x) mask)
- // result: (VPBROADCASTQMasked512 x mask)
+ // match: (VMOVDQU8Masked128 (VPMOVSXBD128 x) mask)
+ // result: (VPMOVSXBDMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPBROADCASTQ512 {
+ if v_0.Op != OpAMD64VPMOVSXBD128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPBROADCASTQMasked512)
+ v.reset(OpAMD64VPMOVSXBDMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VRNDSCALEPD512 [a] x) mask)
- // result: (VRNDSCALEPDMasked512 [a] x mask)
+ // match: (VMOVDQU8Masked128 (VPMOVSXBQ128 x) mask)
+ // result: (VPMOVSXBQMasked128 x mask)
for {
- if v_0.Op != OpAMD64VRNDSCALEPD512 {
+ if v_0.Op != OpAMD64VPMOVSXBQ128 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRNDSCALEPDMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVSXBQMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VREDUCEPD512 [a] x) mask)
- // result: (VREDUCEPDMasked512 [a] x mask)
+ // match: (VMOVDQU8Masked128 (VPMOVZXBW128 x) mask)
+ // result: (VPMOVZXBWMasked128 x mask)
for {
- if v_0.Op != OpAMD64VREDUCEPD512 {
+ if v_0.Op != OpAMD64VPMOVZXBW128 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VREDUCEPDMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVZXBWMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VDIVPD512 x y) mask)
- // result: (VDIVPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPMOVZXBD128 x) mask)
+ // result: (VPMOVZXBDMasked128 x mask)
for {
- if v_0.Op != OpAMD64VDIVPD512 {
+ if v_0.Op != OpAMD64VPMOVZXBD128 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VDIVPDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVZXBDMasked128)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPLZCNTQ512 x) mask)
- // result: (VPLZCNTQMasked512 x mask)
+ // match: (VMOVDQU8Masked128 (VPMOVZXBQ128 x) mask)
+ // result: (VPMOVZXBQMasked128 x mask)
for {
- if v_0.Op != OpAMD64VPLZCNTQ512 {
+ if v_0.Op != OpAMD64VPMOVZXBQ128 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPLZCNTQMasked512)
+ v.reset(OpAMD64VPMOVZXBQMasked128)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VMAXPD512 x y) mask)
- // result: (VMAXPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VGF2P8AFFINEINVQB128 [a] x y) mask)
+ // result: (VGF2P8AFFINEINVQBMasked128 [a] x y mask)
for {
- if v_0.Op != OpAMD64VMAXPD512 {
+ if v_0.Op != OpAMD64VGF2P8AFFINEINVQB128 {
break
}
+ a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VMAXPDMasked512)
+ v.reset(OpAMD64VGF2P8AFFINEINVQBMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPMAXSQ512 x y) mask)
- // result: (VPMAXSQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VGF2P8AFFINEQB128 [a] x y) mask)
+ // result: (VGF2P8AFFINEQBMasked128 [a] x y mask)
for {
- if v_0.Op != OpAMD64VPMAXSQ512 {
+ if v_0.Op != OpAMD64VGF2P8AFFINEQB128 {
break
}
+ a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXSQMasked512)
+ v.reset(OpAMD64VGF2P8AFFINEQBMasked128)
+ v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPMAXUQ512 x y) mask)
- // result: (VPMAXUQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VGF2P8MULB128 x y) mask)
+ // result: (VGF2P8MULBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMAXUQ512 {
+ if v_0.Op != OpAMD64VGF2P8MULB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMAXUQMasked512)
+ v.reset(OpAMD64VGF2P8MULBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VMINPD512 x y) mask)
- // result: (VMINPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPMAXSB128 x y) mask)
+ // result: (VPMAXSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VMINPD512 {
+ if v_0.Op != OpAMD64VPMAXSB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VMINPDMasked512)
+ v.reset(OpAMD64VPMAXSBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPMINSQ512 x y) mask)
- // result: (VPMINSQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPMAXUB128 x y) mask)
+ // result: (VPMAXUBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMINSQ512 {
+ if v_0.Op != OpAMD64VPMAXUB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMINSQMasked512)
+ v.reset(OpAMD64VPMAXUBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPMINUQ512 x y) mask)
- // result: (VPMINUQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPMINSB128 x y) mask)
+ // result: (VPMINSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMINUQ512 {
+ if v_0.Op != OpAMD64VPMINSB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMINUQMasked512)
+ v.reset(OpAMD64VPMINSBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VFMADD213PD512 x y z) mask)
- // result: (VFMADD213PDMasked512 x y z mask)
+ // match: (VMOVDQU8Masked128 (VPMINUB128 x y) mask)
+ // result: (VPMINUBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VFMADD213PD512 {
+ if v_0.Op != OpAMD64VPMINUB128 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
y := v_0.Args[1]
+ x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VFMADD213PDMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPMINUBMasked128)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VFMADDSUB213PD512 x y z) mask)
- // result: (VFMADDSUB213PDMasked512 x y z mask)
+ // match: (VMOVDQU8Masked128 (VPOPCNTB128 x) mask)
+ // result: (VPOPCNTBMasked128 x mask)
for {
- if v_0.Op != OpAMD64VFMADDSUB213PD512 {
+ if v_0.Op != OpAMD64VPOPCNTB128 {
break
}
- z := v_0.Args[2]
x := v_0.Args[0]
- y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VFMADDSUB213PDMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPOPCNTBMasked128)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VMULPD512 x y) mask)
- // result: (VMULPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPERMI2B128 x y z) mask)
+ // result: (VPERMI2BMasked128 x y z mask)
for {
- if v_0.Op != OpAMD64VMULPD512 {
+ if v_0.Op != OpAMD64VPERMI2B128 {
break
}
- y := v_0.Args[1]
+ z := v_0.Args[2]
x := v_0.Args[0]
+ y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VMULPDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPERMI2BMasked128)
+ v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPMULLQ512 x y) mask)
- // result: (VPMULLQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPSHUFB128 x y) mask)
+ // result: (VPSHUFBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPMULLQ512 {
+ if v_0.Op != OpAMD64VPSHUFB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPMULLQMasked512)
+ v.reset(OpAMD64VPSHUFBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VFMSUBADD213PD512 x y z) mask)
- // result: (VFMSUBADD213PDMasked512 x y z mask)
+ // match: (VMOVDQU8Masked128 (VPSUBB128 x y) mask)
+ // result: (VPSUBBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VFMSUBADD213PD512 {
+ if v_0.Op != OpAMD64VPSUBB128 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
y := v_0.Args[1]
+ x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VFMSUBADD213PDMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPSUBBMasked128)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPOPCNTQ512 x) mask)
- // result: (VPOPCNTQMasked512 x mask)
+ // match: (VMOVDQU8Masked128 (VPSUBSB128 x y) mask)
+ // result: (VPSUBSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPOPCNTQ512 {
+ if v_0.Op != OpAMD64VPSUBSB128 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPOPCNTQMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBSBMasked128)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPORQ512 x y) mask)
- // result: (VPORQMasked512 x y mask)
+ // match: (VMOVDQU8Masked128 (VPSUBUSB128 x y) mask)
+ // result: (VPSUBUSBMasked128 x y mask)
for {
- if v_0.Op != OpAMD64VPORQ512 {
+ if v_0.Op != OpAMD64VPSUBUSB128 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPORQMasked512)
+ v.reset(OpAMD64VPSUBUSBMasked128)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPERMI2PD512 x y z) mask)
- // result: (VPERMI2PDMasked512 x y z mask)
+ return false
+}
+func rewriteValueAMD64_OpAMD64VMOVDQU8Masked256(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VMOVDQU8Masked256 (VPABSB256 x) mask)
+ // result: (VPABSBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPERMI2PD512 {
+ if v_0.Op != OpAMD64VPABSB256 {
break
}
- z := v_0.Args[2]
x := v_0.Args[0]
- y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VPERMI2PDMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPABSBMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPERMI2Q512 x y z) mask)
- // result: (VPERMI2QMasked512 x y z mask)
+ // match: (VMOVDQU8Masked256 (VPADDB256 x y) mask)
+ // result: (VPADDBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMI2Q512 {
+ if v_0.Op != OpAMD64VPADDB256 {
break
}
- z := v_0.Args[2]
- x := v_0.Args[0]
y := v_0.Args[1]
+ x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMI2QMasked512)
- v.AddArg4(x, y, z, mask)
+ v.reset(OpAMD64VPADDBMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPERMPD512 x y) mask)
- // result: (VPERMPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPADDSB256 x y) mask)
+ // result: (VPADDSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMPD512 {
+ if v_0.Op != OpAMD64VPADDSB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMPDMasked512)
+ v.reset(OpAMD64VPADDSBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPERMQ512 x y) mask)
- // result: (VPERMQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPADDUSB256 x y) mask)
+ // result: (VPADDUSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPERMQ512 {
+ if v_0.Op != OpAMD64VPADDUSB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPERMQMasked512)
+ v.reset(OpAMD64VPADDUSBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VRCP14PD512 x) mask)
- // result: (VRCP14PDMasked512 x mask)
+ // match: (VMOVDQU8Masked256 (VPAVGB256 x y) mask)
+ // result: (VPAVGBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VRCP14PD512 {
+ if v_0.Op != OpAMD64VPAVGB256 {
break
}
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRCP14PDMasked512)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPAVGBMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VRSQRT14PD512 x) mask)
- // result: (VRSQRT14PDMasked512 x mask)
+ // match: (VMOVDQU8Masked256 (VPBROADCASTB256 x) mask)
+ // result: (VPBROADCASTBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VRSQRT14PD512 {
+ if v_0.Op != OpAMD64VPBROADCASTB256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VRSQRT14PDMasked512)
+ v.reset(OpAMD64VPBROADCASTBMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPROLQ512 [a] x) mask)
- // result: (VPROLQMasked512 [a] x mask)
+ // match: (VMOVDQU8Masked256 (VPMOVSXBW256 x) mask)
+ // result: (VPMOVSXBWMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPROLQ512 {
+ if v_0.Op != OpAMD64VPMOVSXBW256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPROLQMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVSXBWMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPRORQ512 [a] x) mask)
- // result: (VPRORQMasked512 [a] x mask)
+ // match: (VMOVDQU8Masked256 (VPMOVSXBD256 x) mask)
+ // result: (VPMOVSXBDMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPRORQ512 {
+ if v_0.Op != OpAMD64VPMOVSXBD256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPRORQMasked512)
- v.AuxInt = uint8ToAuxInt(a)
+ v.reset(OpAMD64VPMOVSXBDMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPROLVQ512 x y) mask)
- // result: (VPROLVQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMOVSXBQ256 x) mask)
+ // result: (VPMOVSXBQMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPROLVQ512 {
+ if v_0.Op != OpAMD64VPMOVSXBQ256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPROLVQMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVSXBQMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPRORVQ512 x y) mask)
- // result: (VPRORVQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMOVZXBW256 x) mask)
+ // result: (VPMOVZXBWMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPRORVQ512 {
+ if v_0.Op != OpAMD64VPMOVZXBW256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPRORVQMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVZXBWMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VSCALEFPD512 x y) mask)
- // result: (VSCALEFPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMOVZXBD256 x) mask)
+ // result: (VPMOVZXBDMasked256 x mask)
for {
- if v_0.Op != OpAMD64VSCALEFPD512 {
+ if v_0.Op != OpAMD64VPMOVZXBD256 {
break
}
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VSCALEFPDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVZXBDMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSHLDQ512 [a] x y) mask)
- // result: (VPSHLDQMasked512 [a] x y mask)
+ // match: (VMOVDQU8Masked256 (VPMOVZXBQ256 x) mask)
+ // result: (VPMOVZXBQMasked256 x mask)
for {
- if v_0.Op != OpAMD64VPSHLDQ512 {
+ if v_0.Op != OpAMD64VPMOVZXBQ256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
- y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHLDQMasked512)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPMOVZXBQMasked256)
+ v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSLLQ512 x y) mask)
- // result: (VPSLLQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VGF2P8AFFINEINVQB256 [a] x y) mask)
+ // result: (VGF2P8AFFINEINVQBMasked256 [a] x y mask)
for {
- if v_0.Op != OpAMD64VPSLLQ512 {
+ if v_0.Op != OpAMD64VGF2P8AFFINEINVQB256 {
break
}
+ a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLQMasked512)
+ v.reset(OpAMD64VGF2P8AFFINEINVQBMasked256)
+ v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSHRDQ512 [a] x y) mask)
- // result: (VPSHRDQMasked512 [a] x y mask)
+ // match: (VMOVDQU8Masked256 (VGF2P8AFFINEQB256 [a] x y) mask)
+ // result: (VGF2P8AFFINEQBMasked256 [a] x y mask)
for {
- if v_0.Op != OpAMD64VPSHRDQ512 {
+ if v_0.Op != OpAMD64VGF2P8AFFINEQB256 {
break
}
a := auxIntToUint8(v_0.AuxInt)
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSHRDQMasked512)
+ v.reset(OpAMD64VGF2P8AFFINEQBMasked256)
v.AuxInt = uint8ToAuxInt(a)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSRAQ512 x y) mask)
- // result: (VPSRAQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VGF2P8MULB256 x y) mask)
+ // result: (VGF2P8MULBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAQ512 {
+ if v_0.Op != OpAMD64VGF2P8MULB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAQMasked512)
+ v.reset(OpAMD64VGF2P8MULBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSRLQ512 x y) mask)
- // result: (VPSRLQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMAXSB256 x y) mask)
+ // result: (VPMAXSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLQ512 {
+ if v_0.Op != OpAMD64VPMAXSB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLQMasked512)
+ v.reset(OpAMD64VPMAXSBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSHLDVQ512 x y z) mask)
- // result: (VPSHLDVQMasked512 x y z mask)
- for {
- if v_0.Op != OpAMD64VPSHLDVQ512 {
- break
- }
- z := v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- mask := v_1
- v.reset(OpAMD64VPSHLDVQMasked512)
- v.AddArg4(x, y, z, mask)
- return true
- }
- // match: (VMOVDQU64Masked512 (VPSLLVQ512 x y) mask)
- // result: (VPSLLVQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMAXUB256 x y) mask)
+ // result: (VPMAXUBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSLLVQ512 {
+ if v_0.Op != OpAMD64VPMAXUB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLVQMasked512)
+ v.reset(OpAMD64VPMAXUBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSHRDVQ512 x y z) mask)
- // result: (VPSHRDVQMasked512 x y z mask)
- for {
- if v_0.Op != OpAMD64VPSHRDVQ512 {
- break
- }
- z := v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- mask := v_1
- v.reset(OpAMD64VPSHRDVQMasked512)
- v.AddArg4(x, y, z, mask)
- return true
- }
- // match: (VMOVDQU64Masked512 (VPSRAVQ512 x y) mask)
- // result: (VPSRAVQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMINSB256 x y) mask)
+ // result: (VPMINSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAVQ512 {
+ if v_0.Op != OpAMD64VPMINSB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAVQMasked512)
+ v.reset(OpAMD64VPMINSBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSRLVQ512 x y) mask)
- // result: (VPSRLVQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPMINUB256 x y) mask)
+ // result: (VPMINUBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLVQ512 {
+ if v_0.Op != OpAMD64VPMINUB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLVQMasked512)
+ v.reset(OpAMD64VPMINUBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VSQRTPD512 x) mask)
- // result: (VSQRTPDMasked512 x mask)
+ // match: (VMOVDQU8Masked256 (VPOPCNTB256 x) mask)
+ // result: (VPOPCNTBMasked256 x mask)
for {
- if v_0.Op != OpAMD64VSQRTPD512 {
+ if v_0.Op != OpAMD64VPOPCNTB256 {
break
}
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VSQRTPDMasked512)
+ v.reset(OpAMD64VPOPCNTBMasked256)
v.AddArg2(x, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VSUBPD512 x y) mask)
- // result: (VSUBPDMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPERMI2B256 x y z) mask)
+ // result: (VPERMI2BMasked256 x y z mask)
for {
- if v_0.Op != OpAMD64VSUBPD512 {
+ if v_0.Op != OpAMD64VPERMI2B256 {
break
}
- y := v_0.Args[1]
+ z := v_0.Args[2]
x := v_0.Args[0]
+ y := v_0.Args[1]
mask := v_1
- v.reset(OpAMD64VSUBPDMasked512)
- v.AddArg3(x, y, mask)
+ v.reset(OpAMD64VPERMI2BMasked256)
+ v.AddArg4(x, y, z, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSUBQ512 x y) mask)
- // result: (VPSUBQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPSHUFB256 x y) mask)
+ // result: (VPSHUFBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSUBQ512 {
+ if v_0.Op != OpAMD64VPSHUFB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSUBQMasked512)
+ v.reset(OpAMD64VPSHUFBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPXORQ512 x y) mask)
- // result: (VPXORQMasked512 x y mask)
+ // match: (VMOVDQU8Masked256 (VPERMB256 x y) mask)
+ // result: (VPERMBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPXORQ512 {
+ if v_0.Op != OpAMD64VPERMB256 {
break
}
y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPXORQMasked512)
+ v.reset(OpAMD64VPERMBMasked256)
v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSLLQ512const [a] x) mask)
- // result: (VPSLLQMasked512const [a] x mask)
+ // match: (VMOVDQU8Masked256 (VPSUBB256 x y) mask)
+ // result: (VPSUBBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSLLQ512const {
+ if v_0.Op != OpAMD64VPSUBB256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSLLQMasked512const)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBBMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSRLQ512const [a] x) mask)
- // result: (VPSRLQMasked512const [a] x mask)
+ // match: (VMOVDQU8Masked256 (VPSUBSB256 x y) mask)
+ // result: (VPSUBSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRLQ512const {
+ if v_0.Op != OpAMD64VPSUBSB256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRLQMasked512const)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBSBMasked256)
+ v.AddArg3(x, y, mask)
return true
}
- // match: (VMOVDQU64Masked512 (VPSRAQ512const [a] x) mask)
- // result: (VPSRAQMasked512const [a] x mask)
+ // match: (VMOVDQU8Masked256 (VPSUBUSB256 x y) mask)
+ // result: (VPSUBUSBMasked256 x y mask)
for {
- if v_0.Op != OpAMD64VPSRAQ512const {
+ if v_0.Op != OpAMD64VPSUBUSB256 {
break
}
- a := auxIntToUint8(v_0.AuxInt)
+ y := v_0.Args[1]
x := v_0.Args[0]
mask := v_1
- v.reset(OpAMD64VPSRAQMasked512const)
- v.AuxInt = uint8ToAuxInt(a)
- v.AddArg2(x, mask)
+ v.reset(OpAMD64VPSUBUSBMasked256)
+ v.AddArg3(x, y, mask)
return true
}
return false
}
return false
}
+func rewriteValueAMD64_OpAMD64VPAND128(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VPAND128 x (VPMOVMToVec8x16 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU8Masked128 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec8x16 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU8Masked128)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND128 x (VPMOVMToVec16x8 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU16Masked128 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec16x8 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU16Masked128)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND128 x (VPMOVMToVec32x4 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU32Masked128 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec32x4 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU32Masked128)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND128 x (VPMOVMToVec64x2 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU64Masked128 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec64x2 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU64Masked128)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ return false
+}
+func rewriteValueAMD64_OpAMD64VPAND256(v *Value) bool {
+ v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ // match: (VPAND256 x (VPMOVMToVec8x32 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU8Masked256 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec8x32 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU8Masked256)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND256 x (VPMOVMToVec16x16 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU16Masked256 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec16x16 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU16Masked256)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND256 x (VPMOVMToVec32x8 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU32Masked256 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec32x8 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU32Masked256)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ // match: (VPAND256 x (VPMOVMToVec64x4 k))
+ // cond: v.Block.CPUfeatures.hasFeature(CPUavx512)
+ // result: (VMOVDQU64Masked256 x k)
+ for {
+ for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+ x := v_0
+ if v_1.Op != OpAMD64VPMOVMToVec64x4 {
+ continue
+ }
+ k := v_1.Args[0]
+ if !(v.Block.CPUfeatures.hasFeature(CPUavx512)) {
+ continue
+ }
+ v.reset(OpAMD64VMOVDQU64Masked256)
+ v.AddArg2(x, k)
+ return true
+ }
+ break
+ }
+ return false
+}
func rewriteValueAMD64_OpAMD64VPANDD512(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]