汇编 AVX 算术指令 简介

最新推荐文章于 2024-08-26 23:52:00 发布
最新推荐文章于 2024-08-26 23:52:00 发布
阅读量2.2k 收藏 31
点赞数 31
文章标签： 汇编
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73378754/article/details/138723677
版权

简介:用于提高处理器对向量化计算的支持。AVX指令集引入了256位的YMM寄存器，可以同时处理更多的数据，加速并行计算。AVX指令集包括一系列新的指令，用于执行各种数据操作，如浮点运算、整数运算、位操作等。这些指令可以帮助优化各种应用程序的性能，尤其是那些需要大规模数据并行处理的科学、工程和计算应用。通过利用AVX指令集，开发人员可以实现更高效的计算和更快的数据处理速度

应用场景
科学计算包括数值模拟、物理建模、天气预报、地震分析等领域的科学计算应用。
金融建模用于复杂的金融分析、风险管理、投资组合优化等金融业务中的大规模数据处理和计算。
图像处理涉及图像滤波、特征提取、图像识别等领域的图像处理应用程序。
视频编解码用于高清视频处理、视频压缩、实时视频流处理等视频编解码应用。
游戏开发在游戏引擎开发和游戏物理模拟等方面可以利用AVX指令集加速计算。

机器学习

深度学习

用于加速神经网络训练和推理过程，提高机器学习和深度学习模型的性能和效率。
工程仿真提高仿真软件的性能和效率
在这些领域，利用AVX指令集可以加速复杂的数值计算、向量运算、矩阵操作以及其他需要大规模并行计算的任务，从而提高整体的计算性能和效率

 Promoted 256-Bit and 128-bit Arithmetic  Arithmetic 算术指令
VSQRTPS

VSQRTPS xmm1, xmm2/m128
         Computes Square Roots of the packed single precision floating-point values in xmm2/m128 and stores the result in xmm1.

计算源操作数（xmm2/m128）中的四个单精度浮点值的平方根，并将结果存储在目标操作数（xmm1）中


VSQRTPS ymm1, ymm2/m256
         Computes Square Roots of the packed single precision floating-point values in ymm2/m256 and stores the result in ymm1.

计算源操作数（ymm2/m256）中的八个单精度浮点值的平方根，并将结果存储在目标操作数（ymm1）中

VSQRTPS (VEX.256 Encoded Version)
    DEST[31:0] := SQRT(SRC[31:0])
    DEST[63:32] := SQRT(SRC[63:32])
    DEST[95:64] := SQRT(SRC[95:64])
    DEST[127:96] := SQRT(SRC[127:96])
    DEST[159:128] := SQRT(SRC[159:128])
    DEST[191:160] := SQRT(SRC[191:160])
    DEST[223:192] := SQRT(SRC[223:192])
    DEST[255:224] := SQRT(SRC[255:224])

VSQRTPS (VEX.128 Encoded Version)
    DEST[31:0] := SQRT(SRC[31:0])
    DEST[63:32] := SQRT(SRC[63:32])
    DEST[95:64] := SQRT(SRC[95:64])
    DEST[127:96] := SQRT(SRC[127:96])
    DEST[MAXVL-1:128] := 0

VRSQRTPS

VRSQRTPS xmm1, xmm2/m128
         Computes the approximate reciprocals of the square roots of packed single precision values in xmm2/mem and stores the results in xmm1.

计算源操作数（xmm2/m128）中的四个单精度浮点值的近似倒数平方根，并将结果存储在目标操作数（xmm1）中。


VRSQRTPS ymm1, ymm2/m256
         Computes the approximate reciprocals of the square roots of packed single precision values in ymm2/mem and stores the results in ymm1.

计算源操作数（ymm2/m256）中的八个单精度浮点值的近似倒数平方根，并将结果存储在目标操作数（ymm1）中。

倒数平方根是指一个数的平方根的倒数

VRSQRTPS (VEX.128 Encoded Version)
    DEST[31:0] := APPROXIMATE(1/SQRT(SRC[31:0]))
    DEST[63:32] := APPROXIMATE(1/SQRT(SRC1[63:32]))
    DEST[95:64] := APPROXIMATE(1/SQRT(SRC1[95:64]))
    DEST[127:96] := APPROXIMATE(1/SQRT(SRC2[127:96]))
    DEST[MAXVL-1:128] := 0
VRSQRTPS (VEX.256 Encoded Version)
    DEST[31:0] := APPROXIMATE(1/SQRT(SRC[31:0]))
    DEST[63:32] := APPROXIMATE(1/SQRT(SRC1[63:32]))
    DEST[95:64] := APPROXIMATE(1/SQRT(SRC1[95:64]))
    DEST[127:96] := APPROXIMATE(1/SQRT(SRC2[127:96]))
    DEST[159:128] := APPROXIMATE(1/SQRT(SRC2[159:128]))
    DEST[191:160] := APPROXIMATE(1/SQRT(SRC2[191:160]))
    DEST[223:192] := APPROXIMATE(1/SQRT(SRC2[223:192]))
    DEST[255:224] := APPROXIMATE(1/SQRT(SRC2[255:224]))

VSQRTPD

VSQRTPD xmm1, xmm2/m128
    Computes Square Roots of the packed double precision floating-point values in xmm2/m128 and stores the result in xmm1.

计算源操作数（xmm2/m128）中的两个双精度浮点值的平方根，并将结果存储在目标操作数（xmm1）中


VSQRTPD ymm1, ymm2/m256
    Computes Square Roots of the packed double precision floating-point values in ymm2/m256 and stores the result in ymm1.

计算源操作数（ymm2/m256）中的四个双精度浮点值的平方根，并将结果存储在目标操作数（ymm1）中

VSQRTPD (VEX.256 Encoded Version)
    DEST[63:0] := SQRT(SRC[63:0])
    DEST[127:64] := SQRT(SRC[127:64])
    DEST[191:128] := SQRT(SRC[191:128])
    DEST[255:192] := SQRT(SRC[255:192])
    DEST[MAXVL-1:256] := 0
.
VSQRTPD (VEX.128 Encoded Version)
    DEST[63:0] := SQRT(SRC[63:0])
    DEST[127:64] := SQRT(SRC[127:64])
    DEST[MAXVL-1:128] := 0

VRCPPS

VRCPPS xmm1, xmm2/m128
    Computes the approximate reciprocals of packed single precision values in xmm2/mem and stores the results in xmm1.

计算源操作数（xmm2/m128）中的四个单精度浮点值的近似倒数，并将结果存储在目标操作数（xmm1）中

VRCPPS ymm1, ymm2/m256
    Computes the approximate reciprocals of packed single precision values in ymm2/mem and stores the results in ymm1.

计算源操作数（ymm2/m256）中的八个单精度浮点值的近似倒数，并将结果存储在目标操作数（ymm1）中。

VRCPPS (VEX.128 Encoded Version)
    DEST[31:0] := APPROXIMATE(1/SRC[31:0])
    DEST[63:32] := APPROXIMATE(1/SRC[63:32])
    DEST[95:64] := APPROXIMATE(1/SRC[95:64])
    DEST[127:96] := APPROXIMATE(1/SRC[127:96])
    DEST[MAXVL-1:128] := 0
VRCPPS (VEX.256 Encoded Version)
    DEST[31:0] := APPROXIMATE(1/SRC[31:0])
    DEST[63:32] := APPROXIMATE(1/SRC[63:32])
    DEST[95:64] := APPROXIMATE(1/SRC[95:64])
    DEST[127:96] := APPROXIMATE(1/SRC[127:96])
    DEST[159:128] := APPROXIMATE(1/SRC[159:128])
    DEST[191:160] := APPROXIMATE(1/SRC[191:160])
    DEST[223:192] := APPROXIMATE(1/SRC[223:192])
    DEST[255:224] := APPROXIMATE(1/SRC[255:224])

VADDPS

VADDPS xmm1,xmm2, xmm3/m128
    Add packed single precision floating-point values from xmm3/m128 to xmm2 and store result in xmm1.

"执行xmm2和xmm3/mem中的四个单精度浮点值的打包单精度浮点加法，并将结果存储在xmm1中

VADDPS ymm1, ymm2, ymm3/m256
    Add packed single precision floating-point values from ymm3/m256 to ymm2 and store result in ymm1.

计算源操作数（ymm2/m256）中的八个单精度浮点值的近似倒数，并将结果存储在目标操作数（ymm1）中


VADDPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] + SRC2[31:0]
    DEST[63:32] := SRC1[63:32] + SRC2[63:32]
    DEST[95:64] := SRC1[95:64] + SRC2[95:64]
    DEST[127:96] := SRC1[127:96] + SRC2[127:96]
    DEST[159:128] := SRC1[159:128] + SRC2[159:128]
    DEST[191:160]:= SRC1[191:160] + SRC2[191:160]
    DEST[223:192] := SRC1[223:192] + SRC2[223:192]
    DEST[255:224] := SRC1[255:224] + SRC2[255:224].
    DEST[MAXVL-1:256] := 0
VADDPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] + SRC2[31:0]
    DEST[63:32] := SRC1[63:32] + SRC2[63:32]
    DEST[95:64] := SRC1[95:64] + SRC2[95:64]
    DEST[127:96] := SRC1[127:96] + SRC2[127:96]
    DEST[MAXVL-1:128] := 0

VADDPD

VADDPD xmm1,xmm2, xmm3/m128
    Add packed double precision floating-point values from xmm3/mem to xmm2 and store result in xmm1.

执行的是将xmm2和xmm3/mem中的两个双精度浮点值进行打包双精度浮点加法，并将结果存储在xmm1中

VADDPD ymm1, ymm2, ymm3/m256
    Add packed double precision floating-point values from ymm3/mem to ymm2 and store result in ymm1.

执行的是将ymm2和ymm3/mem中的四个双精度浮点值进行打包双精度浮点加法，并将结果存储在ymm1中

VADDPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] + SRC2[63:0]
    DEST[127:64] := SRC1[127:64] + SRC2[127:64]
    DEST[191:128] := SRC1[191:128] + SRC2[191:128]
    DEST[255:192] := SRC1[255:192] + SRC2[255:192]
    DEST[MAXVL-1:256] := 0


VADDPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] + SRC2[63:0]
    DEST[127:64] := SRC1[127:64] + SRC2[127:64]
    DEST[MAXVL-1:128] := 0

VSUBPS

VSUBPS xmm1,xmm2, xmm3/m128
         Subtract packed single precision floating-point values in xmm3/mem from xmm2 and stores result in xmm1.

执行的是将xmm2和xmm3/mem中的四个单精度浮点值进行打包单精度浮点减法，并将结果存储在xmm1中

VSUBPS ymm1, ymm2, ymm3/m256

        Subtract packed single precision floating-point values in ymm3/mem from ymm2 and stores result in ymm1

执行的是将ymm2和ymm3/mem中的八个单精度浮点值进行打包单精度浮点减法，并将结果存储在ymm1中

VSUBPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC2[31:0]
    DEST[63:32] := SRC1[63:32] - SRC2[63:32]
    DEST[95:64] := SRC1[95:64] - SRC2[95:64]
    DEST[127:96] := SRC1[127:96] - SRC2[127:96]
    DEST[159:128] := SRC1[159:128] - SRC2[159:128]
    DEST[191:160] := SRC1[191:160] - SRC2[191:160]
    DEST[223:192] := SRC1[223:192] - SRC2[223:192]
    DEST[255:224] := SRC1[255:224] - SRC2[255:224].
    DEST[MAXVL-1:256] := 0
VSUBPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC2[31:0]
    DEST[63:32] := SRC1[63:32] - SRC2[63:32]
    DEST[95:64] := SRC1[95:64] - SRC2[95:64]
    DEST[127:96] := SRC1[127:96] - SRC2[127:96]
    DEST[MAXVL-1:128] := 0

VSUBPD

VSUBPD xmm1,xmm2, xmm3/m128
    Subtract packed double precision floating-point values in xmm3/mem from xmm2 and store result in xmm1.

"执行的是将xmm2和xmm3/mem中的两个双精度浮点值进行打包双精度浮点减法，并将结果存储在xmm1中

VSUBPD ymm1, ymm2, ymm3/m256

    Subtract packed double precision floating-point values in ymm3/mem from ymm2 and store result in ymm1.

执行的是将ymm2和ymm3/mem中的四个双精度浮点值进行打包双精度浮点减法，并将结果存储在ymm1中


VSUBPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC2[63:0]
    DEST[127:64] := SRC1[127:64] - SRC2[127:64]
    DEST[MAXVL-1:128] := 0

VSUBPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC2[63:0]
    DEST[127:64] := SRC1[127:64] - SRC2[127:64]
    DEST[191:128] := SRC1[191:128] - SRC2[191:128]
    DEST[255:192] := SRC1[255:192] - SRC2[255:192]
    DEST[MAXVL-1:256] := 0

VMULPS

VMULPS xmm1,xmm2, xmm3/m128
     Multiply packed single precision floating-point values in xmm3/m128 with xmm2 and store result in xmm1.

        将xmm2和xmm3/mem中的四个单精度浮点值进行打包单精度浮点乘法，并将结果存储在xmm1中

VMULPS ymm1, ymm2, ymm3/m256
    Multiply packed single precision floating-point values in ymm3/m256 with ymm2 and store result in ymm1.

将ymm2和ymm3/mem中的八个单精度浮点值进行打包单精度浮点乘法，并将结果存储在ymm1中

VMULPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] * SRC2[31:0]
    DEST[63:32] := SRC1[63:32] * SRC2[63:32]
    DEST[95:64] := SRC1[95:64] * SRC2[95:64]
    DEST[127:96] := SRC1[127:96] * SRC2[127:96]
    DEST[159:128] := SRC1[159:128] * SRC2[159:128]
    DEST[191:160] := SRC1[191:160] * SRC2[191:160]
    DEST[223:192] := SRC1[223:192] * SRC2[223:192]
    DEST[255:224] := SRC1[255:224] * SRC2[255:224].
    DEST[MAXVL-1:256] := 0;
VMULPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] * SRC2[31:0]
    DEST[63:32] := SRC1[63:32] * SRC2[63:32]
    DEST[95:64] := SRC1[95:64] * SRC2[95:64]
    DEST[127:96] := SRC1[127:96] * SRC2[127:96]
    DEST[MAXVL-1:128] := 0

VMULPD

VMULPD xmm1,xmm2, xmm3/m128
 Multiply packed double precision floating-point values in xmm3/m128 with xmm2 and store result in xmm1.

将xmm2和xmm3/mem中的两个双精度浮点值进行打包双精度浮点乘法，并将结果存储在xmm1中

VMULPD ymm1, ymm2, ymm3/m256
    Multiply packed double precision floating-point values in ymm3/m256 with ymm2 and store result in ymm1.

将ymm2和ymm3/mem中的四个双精度浮点值进行打包双精度浮点乘法，并将结果存储在ymm1中

VMULPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] * SRC2[63:0]
    DEST[127:64] := SRC1[127:64] * SRC2[127:64]
    DEST[191:128] := SRC1[191:128] * SRC2[191:128]
    DEST[255:192] := SRC1[255:192] * SRC2[255:192]
    DEST[MAXVL-1:256] := 0;

VMULPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] * SRC2[63:0]
    DEST[127:64] := SRC1[127:64] * SRC2[127:64]
    DEST[MAXVL-1:128] := 0

VDIVPS

VDIVPS xmm1, xmm2, xmm3/m128
    Divide packed single precision floating-point values in xmm2 by packed single precision floating-point values in xmm3/mem.

将xmm2中的打包单精度浮点值除以xmm3/m128中的值，并将结果存储在xmm1中。
VDIVPS ymm1, ymm2, ymm3/m256
    Divide packed single precision floating-point values in ymm2 by packed single precision floating-point values in ymm3/mem.

将ymm2中的打包单精度浮点值除以ymm3/m256中的值，并将结果存储在ymm1中


VDIVPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] / SRC2[31:0]
    DEST[63:32] := SRC1[63:32] / SRC2[63:32]
    DEST[95:64] := SRC1[95:64] / SRC2[95:64]
    DEST[127:96] := SRC1[127:96] / SRC2[127:96]
    DEST[159:128] := SRC1[159:128] / SRC2[159:128]
    DEST[191:160] := SRC1[191:160] / SRC2[191:160]
    DEST[223:192] := SRC1[223:192] / SRC2[223:192]
    DEST[255:224] := SRC1[255:224] / SRC2[255:224].
    DEST[MAXVL-1:256] := 0;
VDIVPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] / SRC2[31:0]
    DEST[63:32] := SRC1[63:32] / SRC2[63:32]
    DEST[95:64] := SRC1[95:64] / SRC2[95:64]
    DEST[127:96] := SRC1[127:96] / SRC2[127:96]
    DEST[MAXVL-1:128] := 0

VDIVPD

VDIVPD xmm1, xmm2, xmm3/m128
     Divide packed double precision floating-point values in xmm2 by packed double precision floating-point values in xmm3/mem.

将xmm2中的打包双精度浮点值除以xmm3/m128中的值，并将结果存储在xmm1中

VDIVPD ymm1, ymm2, ymm3/m256
    Divide packed double precision floating-point values in ymm2 by packed double precision floating-point values in ymm3/mem.

将ymm2中的打包双精度浮点值除以ymm3/m256中的值，并将结果存储在ymm1中


VDIVPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] / SRC2[63:0]
    DEST[127:64] := SRC1[127:64] / SRC2[127:64]
    DEST[191:128] := SRC1[191:128] / SRC2[191:128]
    DEST[255:192] := SRC1[255:192] / SRC2[255:192]
    DEST[MAXVL-1:256] := 0;
VDIVPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] / SRC2[63:0]
    DEST[127:64] := SRC1[127:64] / SRC2[127:64]
    DEST[MAXVL-1:128] := 0;

VCVTPS2PD

VCVTPS2PD xmm1, xmm2/m64
         Convert two packed single precision floating-point values in xmm2/m64 to two packed double precision floating-point values in xmm1.

将打包的单精度浮点值从寄存器xmm2/m64转换为打包的双精度浮点值，并将结果存储在寄存器xmm1中。

VCVTPS2PD ymm1, xmm2/m128
         Convert four packed single precision floating-point values in xmm2/m128 to four packed double precision floating-point values in ymm1.

将 xmm2/m128 中的单精度浮点值转换为双精度浮点值，并将结果存储在 ymm1 中

VCVTPS2PD (VEX.256 Encoded Version)
    DEST[63:0] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
    DEST[127:64] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[63:32])
    DEST[191:128] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[95:64])
    DEST[255:192] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[127:96)
    DEST[MAXVL-1:256] := 0
VCVTPS2PD (VEX.128 Encoded Version)
    DEST[63:0] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
    DEST[127:64] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[63:32])
    DEST[MAXVL-1:128] := 0

VCVTPD2PS

VCVTPD2PS xmm1, xmm2/m128
    Convert two packed double precision floating-point values in xmm2/mem to two single precision floatingpoint values in xmm1.

将 xmm2/m128 中的双精度浮点值转换为单精度浮点值，并将结果存储在 xmm1 中

VCVTPD2PS xmm1, ymm2/m256

     Convert four packed double precision floating-point values in ymm2/mem to four single precision floatingpoint values in xmm1.

将 ymm2/m256 中的打包双精度浮点值转换为打包单精度浮点值，并将结果存储在 xmm1 中


VCVTPD2PS (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[127:64])
    DEST[95:64] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[191:128])
    DEST[127:96] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[255:192)
DEST[MAXVL-1:128] := 0
    VCVTPD2PS (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[127:64])
    DEST[MAXVL-1:64] := 0

VCVTDQ2PS

VCVTDQ2PS xmm1, xmm2/m128
     Convert four packed signed doubleword integers from xmm2/mem to four packed single precision floatingpoint values in xmm1.

将 xmm2/m128 中的打包双字整数转换为打包单精度浮点值，并将结果存储在 xmm1 中

VCVTDQ2PS ymm1, ymm2/m256
 Convert eight packed signed doubleword integers from ymm2/mem to eight packed single precision floatingpoint values in ymm1.

将 ymm2/m256 中的打包双字整数转换为打包单精度浮点值，并将结果存储在 ymm1 中

 VCVTDQ2PS (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[31:0])
    DEST[63:32] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[63:32])
    DEST[95:64] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[95:64])
    DEST[127:96] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[127:96)
    DEST[159:128] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[159:128])
    DEST[191:160] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[191:160])
    DEST[223:192] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[223:192])
    DEST[255:224] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[255:224)
    DEST[MAXVL-1:256] := 0
VCVTDQ2PS (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[31:0])
    DEST[63:32] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[63:32])
    DEST[95:64] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[95:64])
    DEST[127:96] := Convert_Integer_To_Single_Precision_Floating_Point(SRC[127z:96)
    DEST[MAXVL-1:128] := 0

VCVTPS2DQ

VCVTPS2DQ xmm1, xmm2/m128
     Convert four packed single precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1.

将 xmm2/m128 中的打包单精度浮点值转换为打包双字整数，并将结果存储在 xmm1 中

VCVTPS2DQ ymm1, ymm2/m256
     Convert eight packed single precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1.

将 ymm2/m256 中的打包单精度浮点值转换为打包双字整数，并将结果存储在 ymm1 中


VCVTPS2DQ (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[31:0])
    DEST[63:32] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[63:32])
    DEST[95:64] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[95:64])
    DEST[127:96] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[127:96)
    DEST[159:128] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[159:128])
    DEST[191:160] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[191:160])
    DEST[223:192] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[223:192])
    DEST[255:224] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[255:224])
VCVTPS2DQ (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[31:0])
    DEST[63:32] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[63:32])
    DEST[95:64] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[95:64])
    DEST[127:96] := Convert_Single_Precision_Floating_Point_To_Integer(SRC[127:96])
    DEST[MAXVL-1:128] := 0

VCVTTPS2DQ

VCVTTPS2DQ xmm1, xmm2/m128
    Convert four packed single precision floating-point values from xmm2/mem to four packed signed doubleword values in xmm1 using truncation.

将 xmm2/m128 中的打包单精度浮点值转换为打包双字整数，并使用截断方式进行转换，然后将结果存储在 xmm1 中


VCVTTPS2DQ ymm1, ymm2/m256
     Convert eight packed single precision floating-point values from ymm2/mem to eight packed signed doubleword values in ymm1 using truncation.

将 ymm2/m256 中的打包单精度浮点值转换为打包双字整数，并使用截断方式进行转换，然后将结果存储在 ymm1 中

VCVTTPS2DQ (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[31:0])
    DEST[63:32] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[63:32])
    DEST[95:64] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[95:64])
    DEST[127:96] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[127:96)
    DEST[159:128] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[159:128])
    DEST[191:160] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[191:160])
    DEST[223:192] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[223:192])
    DEST[255:224] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[255:224

VCVTTPS2DQ (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[31:0])
    DEST[63:32] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[63:32])
    DEST[95:64] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[95:64])
    DEST[127:96] := Convert_Single_Precision_Floating_Point_To_Integer_Truncate(SRC[127:96])
    DEST[MAXVL-1:128] := 0

VCVTTPD2DQ

VCVTTPD2DQ xmm1, xmm2/m128
     Convert two packed double precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1 using truncation.

将 xmm2/m128 中的打包双精度浮点值转换为带有截断的打包双字整数，并将结果存储在 xmm1 中


VCVTTPD2DQ xmm1, ymm2/m256
         Convert four packed double precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1 using truncation.

将 ymm2/m256 中的打包双精度浮点值转换为带有截断的打包双字整数，并将结果存储在 xmm1 中


VCVTTPD2DQ (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[127:64])
    DEST[95:64] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[191:128])
    DEST[127:96] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[255:192)
    DEST[MAXVL-1:128] := 0
VCVTTPD2DQ (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_Floating_Point_To_Integer_Truncate(SRC[127:64])
    DEST[MAXVL-1:64] := 0

VCVTPD2DQ

VCVTPD2DQ xmm1, xmm2/m128
    Convert two packed double precision floating-point values in xmm2/mem to two signed doubleword integers in xmm1.

将 xmm2/m128 中的打包双精度浮点值转换为打包双字整数，并将结果存储在 xmm1 中

VCVTPD2DQ xmm1, ymm2/m256
    Convert four packed double precision floating-point values in ymm2/mem to four signed doubleword integers in xmm1.

将 ymm2/m256 中的打包双精度浮点值转换为打包双字整数，并将结果存储在 xmm1 中

VCVTPD2DQ (VEX.256 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[127:64])
    DEST[95:64] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[191:128])
    DEST[127:96] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[255:192)
    DEST[MAXVL-1:128] := 0
VCVTPD2DQ (VEX.128 Encoded Version)
    DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[63:0])
    DEST[63:32] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[127:64])
    DEST[MAXVL-1:64] := 0

VCVTDQ2PD

VCVTDQ2PD xmm1, xmm2/m64
     Convert two packed signed doubleword integers from xmm2/mem to two packed double precision floating-point values in xmm1.

将 xmm2/m64 中的打包双字整数转换为打包双精度浮点值，并将结果存储在 xmm1 中

VCVTDQ2PD ymm1, xmm2/m128
     Convert four packed signed doubleword integers from xmm2/mem to four packed double precision floating-point values in ymm1.

将 xmm2/m128 中的打包双字整数转换为打包双精度浮点值，并将结果存储在 ymm1 中

VCVTDQ2PD (VEX.256 Encoded Version)
    DEST[63:0] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[31:0])
    DEST[127:64] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[63:32])
    DEST[191:128] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[95:64])
    DEST[255:192] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[127:96)
    DEST[MAXVL-1:256] := 0
VCVTDQ2PD (VEX.128 Encoded Version)
    DEST[63:0] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[31:0])
    DEST[127:64] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[63:32])
    DEST[MAXVL-1:128] := 0

VMINPS

VMINPS xmm1, xmm2, xmm3/m128
     Return the minimum single precision floating-point values between xmm2 and xmm3/mem.

比较 xmm2 和 xmm3/mem128 中的打包单精度浮点值，并将每对值中的最小值存储在 xmm1 中。

VMINPS ymm1, ymm2, ymm3/m256
    Return the minimum single double precision floating-point values between ymm2 and ymm3/mem.

比较 ymm2 和 ymm3/mem256 中的打包单精度浮点值，并将每对值中的最小值存储在 ymm1 中。

VMINPS (VEX.256 Encoded Version)
    DEST[31:0] := MIN(SRC1[31:0], SRC2[31:0])
    DEST[63:32] := MIN(SRC1[63:32], SRC2[63:32])
    DEST[95:64] := MIN(SRC1[95:64], SRC2[95:64])
    DEST[127:96] := MIN(SRC1[127:96], SRC2[127:96])
    DEST[159:128] := MIN(SRC1[159:128], SRC2[159:128])
    DEST[191:160] := MIN(SRC1[191:160], SRC2[191:160])
    DEST[223:192] := MIN(SRC1[223:192], SRC2[223:192])
    DEST[255:224] := MIN(SRC1[255:224], SRC2[255:224])
VMINPS (VEX.128 Encoded Version)
    DEST[31:0] := MIN(SRC1[31:0], SRC2[31:0])
    DEST[63:32] := MIN(SRC1[63:32], SRC2[63:32])
    DEST[95:64] := MIN(SRC1[95:64], SRC2[95:64])
    DEST[127:96] := MIN(SRC1[127:96], SRC2[127:96])
    DEST[MAXVL-1:128] := 0

VMINPD

VMINPD xmm1, xmm2, xmm3/m128
     Return the minimum double precision floating-point values between xmm2 and xmm3/mem.

比较 xmm2 和 xmm3/mem128 中的打包双精度浮点值，并将每对值中的最小值存储在 xmm1 中。

VMINPD ymm1, ymm2, ymm3/m256
     Return the minimum packed double precision floating-point values between ymm2 and ymm3/mem.

比较 ymm2 和 ymm3/mem256 中的打包双精度浮点值，并将每对值中的最小值存储在 ymm1 中。

VMINPD (VEX.256 Encoded Version)
    DEST[63:0] := MIN(SRC1[63:0], SRC2[63:0])
    DEST[127:64] := MIN(SRC1[127:64], SRC2[127:64])
    DEST[191:128] := MIN(SRC1[191:128], SRC2[191:128])
    DEST[255:192] := MIN(SRC1[255:192], SRC2[255:192])
VMINPD (VEX.128 Encoded Version)
    DEST[63:0] := MIN(SRC1[63:0], SRC2[63:0])
    DEST[127:64] := MIN(SRC1[127:64], SRC2[127:64])
    DEST[MAXVL-1:128] := 0

VMAXPS

VMAXPS xmm1, xmm2, xmm3/m128
         Return the maximum single precision floating-point values between xmm2 and xmm3/mem.

比较 xmm2 和 xmm3/mem128 中的打包单精度浮点值，并将每对值中的最大值存储在 xmm1 中。

VMAXPS ymm1, ymm2, ymm3/m256
    Return the maximum single precision floating-point values between ymm2 and ymm3/mem.

比较 ymm2 和 ymm3/mem256 中的打包单精度浮点值，并将每对值中的最大值存储在 ymm1 中


VMAXPS (VEX.256 Encoded Version)
    DEST[31:0] := MAX(SRC1[31:0], SRC2[31:0])
    DEST[63:32] := MAX(SRC1[63:32], SRC2[63:32])
    DEST[95:64] := MAX(SRC1[95:64], SRC2[95:64])
    DEST[127:96] := MAX(SRC1[127:96], SRC2[127:96])
    DEST[159:128] := MAX(SRC1[159:128], SRC2[159:128])
    DEST[191:160] := MAX(SRC1[191:160], SRC2[191:160])
    DEST[223:192] := MAX(SRC1[223:192], SRC2[223:192])
    DEST[255:224] := MAX(SRC1[255:224], SRC2[255:224])
    DEST[MAXVL-1:256] := 0
VMAXPS (VEX.128 Encoded Version)
    DEST[31:0] := MAX(SRC1[31:0], SRC2[31:0])
    DEST[63:32] := MAX(SRC1[63:32], SRC2[63:32])
    DEST[95:64] := MAX(SRC1[95:64], SRC2[95:64])
    DEST[127:96] := MAX(SRC1[127:96], SRC2[127:96])
    DEST[MAXVL-1:128] := 0

VMAXPD


VMAXPD xmm1, xmm2, xmm3/m128
    Return the maximum double precision floating-point values between xmm2 and xmm3/m128.

比较 xmm2 和 xmm3/mem128 中的打包双精度浮点值，并将每对值中的最大值存储在 xmm1 中

VMAXPD ymm1, ymm2, ymm3/m256
 Return the maximum packed double precision floatingpoint values between ymm2 and ymm3/m256.

比较 ymm2 和 ymm3/mem256 中的打包双精度浮点值，并将每对值中的最大值存储在 ymm1 中


VMAXPD (VEX.256 Encoded Version)
    DEST[63:0] := MAX(SRC1[63:0], SRC2[63:0])
    DEST[127:64] := MAX(SRC1[127:64], SRC2[127:64])
    DEST[191:128] := MAX(SRC1[191:128], SRC2[191:128])
    DEST[255:192] := MAX(SRC1[255:192], SRC2[255:192])
    DEST[MAXVL-1:256] := 0
VMAXPD (VEX.128 Encoded Version)
    DEST[63:0] := MAX(SRC1[63:0], SRC2[63:0])
    DEST[127:64] := MAX(SRC1[127:64], SRC2[127:64])
    DEST[MAXVL-1:128] := 0

VHADDPD

VHADDPD xmm1,xmm2, xmm3/m128
    Horizontal add packed double precision floating-point values from xmm2 and xmm3/mem.

从xmm2和xmm3/mem128中水平添加双精度浮点值的对，并将结果存储在xmm1中


VHADDPD ymm1, ymm2, ymm3/m256
     Horizontal add packed double precision floating-point values from ymm2 and ymm3/mem.

从ymm2和ymm3/mem256中水平添加双精度浮点值的对，并将结果存储在ymm1中


VHADDPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[127:64] + SRC1[63:0]
    DEST[127:64] := SRC2[127:64] + SRC2[63:0]
    DEST[MAXVL-1:128] := 0
VHADDPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[127:64] + SRC1[63:0]
    DEST[127:64] := SRC2[127:64] + SRC2[63:0]
    DEST[191:128] := SRC1[255:192] + SRC1[191:128]
    DEST[255:192] := SRC2[255:192] + SRC2[191:128]

VHADDPS

VHADDPS xmm1, xmm2, xmm3/m128
         Horizontal add packed single precision floatingpoint values from xmm2 and xmm3/mem.

        从xmm2和xmm3/mem128中水平添加单精度浮点值的对，并将结果存储在xmm1中

VHADDPS ymm1, ymm2, ymm3/m256
 Horizontal add packed single precision floatingpoint values from ymm2 and ymm3/mem.

从ymm2和ymm3/mem256中水平添加单精度浮点值的对，并将结果存储在ymm1中
 VHADDPS (VEX.128 Encoded Version)
DEST[31:0] := SRC1[63:32] + SRC1[31:0]
DEST[63:32] := SRC1[127:96] + SRC1[95:64]
DEST[95:64] := SRC2[63:32] + SRC2[31:0]
DEST[127:96] := SRC2[127:96] + SRC2[95:64] 
DEST[MAXVL-1:128] := 0
VHADDPS (VEX.256 Encoded Version)
DEST[31:0] := SRC1[63:32] + SRC1[31:0]
DEST[63:32] := SRC1[127:96] + SRC1[95:64]
DEST[95:64] := SRC2[63:32] + SRC2[31:0]
DEST[127:96] := SRC2[127:96] + SRC2[95:64] 
DEST[159:128] := SRC1[191:160] + SRC1[159:128]
DEST[191:160] := SRC1[255:224] + SRC1[223:192]
DEST[223:192] := SRC2[191:160] + SRC2[159:128]
DEST[255:224] := SRC2[255:224] + SRC2[223:192]

VHSUBPD

VHSUBPD xmm1,xmm2, xmm3/m128
    Horizontal subtract packed double precision floating-point values from xmm2 and xmm3/mem.

从xmm2和xmm3/mem128中水平减去双精度浮点值的对，并将结果存储在xmm1中

VHSUBPD ymm1, ymm2, ymm3/m256
 Horizontal subtract packed double precision floating-point values from ymm2 and ymm3/mem.

从ymm2和ymm3/mem256中水平减去双精度浮点值的对，并将结果存储在ymm1中


 VHSUBPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC1[127:64] 
    DEST[127:64] := SRC2[63:0] - SRC2[127:64] 
    DEST[MAXVL-1:128] := 0
VHSUBPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC1[127:64] 
    DEST[127:64] := SRC2[63:0] - SRC2[127:64] 
    DEST[191:128] := SRC1[191:128] - SRC1[255:192]
    DEST[255:192] := SRC2[191:128] - SRC2[255:192]

VHSUBPS

VHSUBPS xmm1, xmm2, xmm3/m128
    Horizontal subtract packed single precision floating-point values from xmm2 and xmm3/mem.

从xmm2和xmm3/mem128中水平减去单精度浮点值的对，并将结果存储在xmm1中

VHSUBPS ymm1, ymm2, ymm3/m256
     Horizontal subtract packed single precision floating-point values from ymm2 and ymm3/mem.

从ymm2和ymm3/mem256中水平减去单精度浮点值的对，并将结果存储在ymm1中

VHSUBPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC1[63:32]
    DEST[63:32] := SRC1[95:64] - SRC1[127:96]
    DEST[95:64] := SRC2[31:0] - SRC2[63:32]
    DEST[127:96] := SRC2[95:64] - SRC2[127:96] 
    DEST[MAXVL-1:128] := 0
VHSUBPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC1[63:32]
    DEST[63:32] := SRC1[95:64] - SRC1[127:96]
    DEST[95:64] := SRC2[31:0] - SRC2[63:32]
    DEST[127:96] := SRC2[95:64] - SRC2[127:96] 
    DEST[159:128] := SRC1[159:128] - SRC1[191:160]
    DEST[191:160] := SRC1[223:192] - SRC1[255:224]
    DEST[223:192] := SRC2[159:128] - SRC2[191:160]
    DEST[255:224] := SRC2[223:192] - SRC2[255:224]

VCMPPS

VCMPPS xmm1, xmm2, xmm3/m128, imm8
    Compare packed single precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

imm8" 用于根据imm8中指定的条件，在xmm2和xmm3/mem128中的单精度浮点值进行比较，并将结果存储在xmm1中。

VCMPPS ymm1, ymm2, ymm3/m256, imm8
     Compare packed single precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

根据imm8中指定的条件，在ymm2和ymm3/mem256中的单精度浮点值进行比较，并将结果存储在ymm1中

CASE (COMPARISON PREDICATE) OF
    0: OP3 := EQ_OQ; OP5 := EQ_OQ;
    1: OP3 := LT_OS; OP5 := LT_OS;
    2: OP3 := LE_OS; OP5 := LE_OS;
    3: OP3 := UNORD_Q; OP5 := UNORD_Q;
    4: OP3 := NEQ_UQ; OP5 := NEQ_UQ;
    5: OP3 := NLT_US; OP5 := NLT_US;
    6: OP3 := NLE_US; OP5 := NLE_US;
    7: OP3 := ORD_Q; OP5 := ORD_Q;
    8: OP5 := EQ_UQ;
    9: OP5 := NGE_US;
    10: OP5 := NGT_US;
    11: OP5 := FALSE_OQ;
    12: OP5 := NEQ_OQ;
    13: OP5 := GE_OS;
    14: OP5 := GT_OS;
    15: OP5 := TRUE_UQ;
    16: OP5 := EQ_OS;
    17: OP5 := LT_OQ;
    18: OP5 := LE_OQ;
    19: OP5 := UNORD_S;
    20: OP5 := NEQ_US;
    21: OP5 := NLT_UQ;
    22: OP5 := NLE_UQ;
    23: OP5 := ORD_S;
    24: OP5 := EQ_US;
    25: OP5 := NGE_UQ;
    26: OP5 := NGT_UQ;
    27: OP5 := FALSE_OS;
    28: OP5 := NEQ_OS;
    29: OP5 := GE_OQ;
    30: OP5 := GT_OQ;
    31: OP5 := TRUE_US;
    DEFAULT: Reserved
ESAC;

VCMPPS (VEX.256 Encoded Version)
	CMP0 := SRC1[31:0] OP5 SRC2[31:0];
	CMP1 := SRC1[63:32] OP5 SRC2[63:32];
	CMP2 := SRC1[95:64] OP5 SRC2[95:64];
	CMP3 := SRC1[127:96] OP5 SRC2[127:96];
	CMP4 := SRC1[159:128] OP5 SRC2[159:128];
	CMP5 := SRC1[191:160] OP5 SRC2[191:160];
	CMP6 := SRC1[223:192] OP5 SRC2[223:192];
	CMP7 := SRC1[255:224] OP5 SRC2[255:224];
	IF CMP0 = TRUE
	THEN DEST[31:0] :=FFFFFFFFH;
	ELSE DEST[31:0] := 000000000H; FI;
	IF CMP1 = TRUE
	THEN DEST[63:32] := FFFFFFFFH;
	ELSE DEST[63:32] :=000000000H; FI;
	IF CMP2 = TRUE
	THEN DEST[95:64] := FFFFFFFFH;
	ELSE DEST[95:64] := 000000000H; FI;
	IF CMP3 = TRUE
	THEN DEST[127:96] := FFFFFFFFH;
	ELSE DEST[127:96] := 000000000H; FI;
	IF CMP4 = TRUE
	THEN DEST[159:128] := FFFFFFFFH;
	ELSE DEST[159:128] := 000000000H; FI;
	IF CMP5 = TRUE
	THEN DEST[191:160] := FFFFFFFFH;
	ELSE DEST[191:160] := 000000000H; FI;
	IF CMP6 = TRUE
	THEN DEST[223:192] := FFFFFFFFH;
	ELSE DEST[223:192] :=000000000H; FI;
	IF CMP7 = TRUE
	THEN DEST[255:224] := FFFFFFFFH;
	ELSE DEST[255:224] := 000000000H; FI;
	DEST[MAXVL-1:256] := 0

VCMPPS (VEX.128 Encoded Version)
	CMP0 := SRC1[31:0] OP5 SRC2[31:0];
	CMP1 := SRC1[63:32] OP5 SRC2[63:32];
	CMP2 := SRC1[95:64] OP5 SRC2[95:64];
	CMP3 := SRC1[127:96] OP5 SRC2[127:96];
	IF CMP0 = TRUE
	THEN DEST[31:0] :=FFFFFFFFH;
	ELSE DEST[31:0] := 000000000H; FI;
	IF CMP1 = TRUE
	THEN DEST[63:32] := FFFFFFFFH;
	ELSE DEST[63:32] := 000000000H; FI;
	IF CMP2 = TRUE
	THEN DEST[95:64] := FFFFFFFFH;
	ELSE DEST[95:64] := 000000000H; FI;
	IF CMP3 = TRUE
	THEN DEST[127:96] := FFFFFFFFH;
	ELSE DEST[127:96] :=000000000H; FI;
	DEST[MAXVL-1:128] := 0

VCMPPD

VCMPPD xmm1, xmm2, xmm3/m128, imm8
 Compare packed double precision floating-point values in xmm3/m128 and xmm2 using bits 4:0 of imm8 as a comparison predicate.

对寄存器XMM2和内存/寄存器XMM3中的双精度浮点数进行比较，比较操作由imm8参数指定。比较的结果将存储在寄存器XMM1中。

VCMPPD ymm1, ymm2, ymm3/m256, imm8
    Compare packed double precision floating-point values in ymm3/m256 and ymm2 using bits 4:0 of imm8 as a comparison predicate.

对寄存器YMM2和内存/寄存器YMM3中的双精度浮点数进行比较，比较操作由imm8参数指定

VCMPPD (VEX.256 Encoded Version)
    CMP0 := SRC1[63:0] OP5 SRC2[63:0];
    CMP1 := SRC1[127:64] OP5 SRC2[127:64];
    CMP2 := SRC1[191:128] OP5 SRC2[191:128];
    CMP3 := SRC1[255:192] OP5 SRC2[255:192];
    IF CMP0 = TRUE
    THEN DEST[63:0] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[63:0] := 0000000000000000H; FI;
    IF CMP1 = TRUE
    THEN DEST[127:64] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[127:64] := 0000000000000000H; FI;
    IF CMP2 = TRUE
    THEN DEST[191:128] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[191:128] := 0000000000000000H; FI;
    IF CMP3 = TRUE
    THEN DEST[255:192] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[255:192] := 0000000000000000H; FI;
    DEST[MAXVL-1:256] := 0
VCMPPD (VEX.128 Encoded Version)
    CMP0 := SRC1[63:0] OP5 SRC2[63:0];
    CMP1 := SRC1[127:64] OP5 SRC2[127:64];
    IF CMP0 = TRUE
    THEN DEST[63:0] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[63:0] := 0000000000000000H; FI;
    IF CMP1 = TRUE
    THEN DEST[127:64] := FFFFFFFFFFFFFFFFH;
    ELSE DEST[127:64] := 0000000000000000H; FI;
    DEST[MAXVL-1:128] := 0

VADDSUBPD

VADDSUBPD xmm1, xmm2, xmm3/m128
 Add/subtract packed double precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

对寄存器XMM2和内存/寄存器XMM3中的双精度浮点数执行打包的加减操作，并将结果存储在寄存器XMM1中

VADDSUBPD ymm1, ymm2, ymm3/m256
    Add / subtract packed double precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

对寄存器YMM2和内存/寄存器YMM3中的双精度浮点数执行打包的加减操作，并将结果存储在寄存器YMM1中


VADDSUBPD (VEX.128 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC2[63:0]
    DEST[127:64] := SRC1[127:64] + SRC2[127:64]
    DEST[MAXVL-1:128] := 0
VADDSUBPD (VEX.256 Encoded Version)
    DEST[63:0] := SRC1[63:0] - SRC2[63:0]
    DEST[127:64] := SRC1[127:64] + SRC2[127:64]
    DEST[191:128] := SRC1[191:128] - SRC2[191:128]
    DEST[255:192] := SRC1[255:192] + SRC2[255:192]

VADDSUBPS

VADDSUBPS xmm1, xmm2, xmm3/m128
    Add/subtract single precision floating-point values from xmm3/mem to xmm2 and stores result in xmm1.

对寄存器XMM2和内存/寄存器XMM3中的单精度浮点数执行打包的加减操作，并将结果存储在寄存器XMM1中

VADDSUBPS ymm1, ymm2, ymm3/m256

 Add / subtract single precision floating-point values from ymm3/mem to ymm2 and stores result in ymm1.

对寄存器YMM2和内存/寄存器YMM3中的单精度浮点数执行打包的加减操作，并将结果存储在寄存器YMM1中

VADDSUBPS (VEX.128 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC2[31:0]
    DEST[63:32] := SRC1[63:32] + SRC2[63:32]
    DEST[95:64] := SRC1[95:64] - SRC2[95:64]
    DEST[127:96] := SRC1[127:96] + SRC2[127:96]
    DEST[MAXVL-1:128] := 0
VADDSUBPS (VEX.256 Encoded Version)
    DEST[31:0] := SRC1[31:0] - SRC2[31:0]
    DEST[63:32] := SRC1[63:32] + SRC2[63:32]
    DEST[95:64] := SRC1[95:64] - SRC2[95:64]
    DEST[127:96] := SRC1[127:96] + SRC2[127:96]
    DEST[159:128] := SRC1[159:128] - SRC2[159:128]
    DEST[191:160] := SRC1[191:160] + SRC2[191:160]
    DEST[223:192] := SRC1[223:192] - SRC2[223:192]
    DEST[255:224] := SRC1[255:224] + SRC2[255:224]

VDPPS

VDPPS xmm1,xmm2, xmm3/m128, imm8

     Multiply packed single precision floating-point values from xmm1 with packed single precision floating-point values from xmm2/mem selectively add and store to xmm1.

对XMM2和XMM3/m128中的单精度浮点数执行打包的点积运算，并将结果存储在XMM1中。imm8参数指定了点积计算的选项，例如选择要相乘和累加的元素。

VDPPS ymm1, ymm2, ymm3/m256, imm8

     Multiply packed single precision floating-point values from ymm2 with packed single precision floating-point values from ymm3/mem, selectively add pairs of elements and store to ymm1.

对YMM2和YMM3/m256中的单精度浮点数执行打包的点积运算，并将结果存储在YMM1中。imm8参数指定了点积计算的选项，例如选择要相乘和累加的元素。

DP_primitive (SRC1, SRC2)
	IF (imm8[4] = 1) 
		THEN Temp1[31:0] := DEST[31:0] * SRC[31:0]; // update SIMD exception flags
		ELSE 
		Temp1[31:0] := +0.0; 
	FI;
	IF (imm8[5] = 1) THEN 
		Temp1[63:32] := DEST[63:32] * SRC[63:32]; // update SIMD exception flags
	ELSE 
		Temp1[63:32] := +0.0; 
	FI;
	IF (imm8[6] = 1) 
		THEN Temp1[95:64] := DEST[95:64] * SRC[95:64]; // update SIMD exception flags
	ELSE 
	Temp1[95:64] := +0.0; 
	FI;
	IF (imm8[7] = 1) 
		THEN Temp1[127:96] := DEST[127:96] * SRC[127:96]; // update SIMD exception flags
	ELSE 
		Temp1[127:96] := +0.0; 
	FI;

	Temp2[31:0] := Temp1[31:0] + Temp1[63:32]; // update SIMD exception flags
	/* if unmasked exception reported, execute exception handler*/
	Temp3[31:0] := Temp1[95:64] + Temp1[127:96]; // update SIMD exception flags
	/* if unmasked exception reported, execute exception handler*/
	Temp4[31:0] := Temp2[31:0] + Temp3[31:0]; // update SIMD exception flags
	/* if unmasked exception reported, execute exception handler*/
	IF (imm8[0] = 1) THEN 
		DEST[31:0] := Temp4[31:0];
	ELSE 
		DEST[31:0] := +0.0; 
		FI;
	IF (imm8[1] = 1) THEN 
		DEST[63:32] := Temp4[31:0];
	ELSE 
		DEST[63:32] := +0.0; 
	FI;
	IF (imm8[2] = 1) THEN 
		DEST[95:64] := Temp4[31:0];
	ELSE 
		DEST[95:64] := +0.0; 
	FI;
	IF (imm8[3] = 1) THEN 
		DEST[127:96] := Temp4[31:0];
	ELSE 
		DEST[127:96] := +0.0; 
	FI;

VDPPS (VEX.128 Encoded Version)
	DEST[127:0] := DP_Primitive(SRC1[127:0], SRC2[127:0]);
	DEST[MAXVL-1:128] := 0
VDPPS (VEX.256 Encoded Version)
	DEST[127:0] := DP_Primitive(SRC1[127:0], SRC2[127:0]);
	DEST[255:128] := DP_Primitive(SRC1[255:128], SRC2[255:128]);

VROUNDPD

VROUNDPD xmm1, xmm2/m128, imm8
     Round packed double precision floating-point values in xmm2/m128 and place the result in xmm1. The rounding mode is determined by imm8.

对寄存器XMM2/m128中的双精度浮点数值根据imm8参数指定的舍入模式进行舍入，并将结果存储在寄存器XMM1中。imm8参数确定要使用的舍入模式，例如四舍五入、向下取整、向上取整或朝零截断。

VROUNDPD ymm1, ymm2/m256, imm8
    Round packed double precision floating-point values in ymm2/m256 and place the result in ymm1. The rounding mode is determined by imm8.

对寄存器YMM2/m256中的双精度浮点数值根据imm8参数指定的舍入模式进行舍入，并将结果存储在寄存器YMM1中。imm8参数确定要使用的舍入模式，例如四舍五入、向下取整、向上取整或朝零截断。

VROUNDPD (VEX.128 Encoded Version)
    DEST[63:0] := RoundToInteger(SRC[63:0]], ROUND_CONTROL)
    DEST[127:64] := RoundToInteger(SRC[127:64]], ROUND_CONTROL)
    DEST[MAXVL-1:128] := 0
VROUNDPD (VEX.256 Encoded Version)
    DEST[63:0] := RoundToInteger(SRC[63:0], ROUND_CONTROL)
    DEST[127:64] := RoundToInteger(SRC[127:64]], ROUND_CONTROL)
    DEST[191:128] := RoundToInteger(SRC[191:128]], ROUND_CONTROL)
    DEST[255:192] := RoundToInteger(SRC[255:192] ], ROUND_CONTROL)

VROUNDPS

VROUNDPS xmm1, xmm2/m128, imm8
     Round packed single precision floating-point values in xmm2/m128 and place the result in xmm1. The rounding mode is determined by imm8.

寄存器XMM2/m128中的单精度浮点数值根据imm8参数指定的舍入模式进行舍入，并将结果存储在寄存器XMM1中。imm8参数确定要使用的舍入模式，例如四舍五入、向下取整、向上取整或朝零截断。

VROUNDPS ymm1, ymm2/m256, imm8
    Round packed single precision floating-point values in ymm2/m256 and place the result in ymm1. The rounding mode is determined by imm8.

对寄存器YMM2/m256中的单精度浮点数值根据imm8参数指定的舍入模式进行舍入，并将结果存储在寄存器YMM1中。imm8参数确定要使用的舍入模式，例如四舍五入、向下取整、向上取整或朝零截断。

VROUNDPS (VEX.128 Encoded Version)
    DEST[31:0] := RoundToInteger(SRC[31:0], ROUND_CONTROL)
    DEST[63:32] := RoundToInteger(SRC[63:32], ROUND_CONTROL)
    DEST[95:64] := RoundToInteger(SRC[95:64]], ROUND_CONTROL)
    DEST[127:96] := RoundToInteger(SRC[127:96]], ROUND_CONTROL)
    DEST[MAXVL-1:128] := 0
VROUNDPS (VEX.256 Encoded Version)
    DEST[31:0] := RoundToInteger(SRC[31:0], ROUND_CONTROL)
    DEST[63:32] := RoundToInteger(SRC[63:32], ROUND_CONTROL)
    DEST[95:64] := RoundToInteger(SRC[95:64]], ROUND_CONTROL)
    DEST[127:96] := RoundToInteger(SRC[127:96]], ROUND_CONTROL)
    DEST[159:128] := RoundToInteger(SRC[159:128]], ROUND_CONTROL)
    DEST[191:160] := RoundToInteger(SRC[191:160]], ROUND_CONTROL)
    DEST[223:192] := RoundToInteger(SRC[223:192] ], ROUND_CONTROL)
    DEST[255:224] := RoundToInteger(SRC[255:224] ], ROUND_CONTROL)

ROUND 的IMM8 值

cmp 的IMM8值: 

程序猴--小川
关注
汇编指令集汇总
10-25
原版高清汇编指令详细解析，让我们一起共同学习，共同进步
AVX指令集测试
11-16
该demo测试avx指令集，参考微软提供的接口可以测试该操作系统是否支持avx指令。
SSE和AVX指令基本使用
最新发布
哦豁灬
08-26 855
SSE/AVX 指令属于 Intrinsics 函数，由编译器在编译时直接在调用处插入代码，避免了函数调用的额外开销。但是与 inline 函数不同，Intrinsics 函数的代码由编译器提供，能够更高效地使用机器指令进行优化调整。一般的函数是在库中，Intrinsic Function 内嵌在编译器中（built in to the compiler）。
AVX指令集
热门推荐
nbu_dahe的博客
12-26 1万+
一、AVX指令集 CPU依靠指令来计算和控制系统，指令集是指CPU能执行的所有指令的集合，每一类CPU都有其支持的指令集。比如说目前intel和AMD的绝大部分处理器都使用X86指令集，因为它们都源自于X86架构。 但无论CPU有多快，X86指令也只能一次处理一个数据，但这种单指令单数据（SISD）的指令集效率并不高，因此，为了提高CPU的工作效率，需要增加一些特殊的指令满足时代进步的需求，这些新增的指令就构成了扩展指令集。 一条指令操作多个数据（SIMD）．是CPU基本指令集的扩展．主要用于提供fine
AVX指令集介绍
jiangxing11的博客
09-20 2480
最近在学习指令集相关知识，刚好来练练手。在正式应用前首先看一段代码吧这段代码很容易理解，依次将各点进行x2y2z2计算，然后赋值给矩阵mB。那么变成AVX指令集加速版本应该是这样的。这段代码中出现了好几个关键的指令集方法，第一次看这个我也是懵逼状态。不过查阅了手册后，很快便能理解AVX指令的一些规则。
SSE与AVX指令基础介绍与使用
ThousandPine的博客
07-14 1675
SSE/AVX指令属于Intrinsics函数，由编译器在编译时直接在调用处插入代码，避免了函数调用的额外开销。但又与inline函数不同，Intrinsics函数的代码由编译器提供，能够更高效地使用机器指令进行优化调整。在开始之前可以先在CPU-Z或者查看自己CPU的指令集支持情况。关于SSE和AVX内部函数的相关信息也都可以在查看。
AVX指令集函数列表
weixin_56819992的博客
05-05 2670
首先计算64位双精度浮点数向量a逻辑与b，如果中间结果4个通道的符号位全为0则设置ZF为1，否则ZF为0.然后先计算64位双精度浮点数向量a的逻辑非，再与向量b做逻辑与，如果该中间结果4个通道的的符号位全为0则设置CF位1，否则CF为1，返回CF。首先计算32位单精度浮点数向量a逻辑与b，如果中间结果的符号位全为0则设置ZF为1，否则ZF为0.然后先计算32位单精度浮点数向量a的逻辑否，再与向量b做逻辑与，如果该中间结果8的符号位全为0则设置CF位1，否则CF为1，返回CF。
AVX介绍
哦豁灬
06-15 1506
SIMD：Single Instruction Multiple Data，单指令多数据，一个指令可以控制多个数据进行操作。在这里，使用的是单指令单数据（SISD）的处理方式，要进行四次加法运算，就当真是进行了四次加法运算，使用了四次加法指令。进行4次加法只需要进行一个长度为4的向量加法，只是用了一次向量加法的指令。在SIMD指令集中，可以控制若干个大寄存器，把这些寄存器中的数据按照某些规则进行统一的操作，相当于一条指令可以完成好几次重复运算，从而达到加快运算速度的效果。
汇编语言--x86汇编指令集大全.zip
10-13
7. **向量和多媒体指令**：如MMX、SSE、AVX系列，这些扩展指令集增加了对并行处理和多媒体数据的支持，提高了处理图像、音频和视频等任务的效率。 学习x86汇编语言，你需要掌握以下几个关键点： - **寄存器**：x86...
Intel汇编指令参考手册
05-09
- **数据处理指令**: 如ADD（加法）、SUB（减法）、MUL（乘法）、DIV（除法）等，用于处理算术和逻辑运算。 - **转移指令**: 如JMP（跳转）、CALL（调用）、RET（返回），用于控制程序流程。 - **输入/输出指令**...
intel SSE2/3/4，AVX指令集
11-09
比较全的指令集，结合intel编译器和VS2008/VS2010使用。
AVX指令集中的32种浮点比较关系详解（NaN、无序、有序等）
weixin_34051201的博客
04-19 544
　　在传统印象中，数字的比较关系只有6种。但在AVX指令集中，Intel一下给出了32种浮点比较谓词，详见下图—— （Intel手册：Table 3-9. Comparison Predicate for VCMPPD and VCMPPS Instructions） 　　为什么会有这么多种比较谓词呢？我为此困惑困惑了很久。　　直到最近翻阅了不少资料后，才终于将它们弄懂了。   一、浮...
[VC] 检测AVX系列指令集的支持级别（AVX、AVX2、F16C、FMA、FMA4、XOP）
weixin_33795743的博客
07-04 817
从2011年的Sandy Bridge微架构处理器开始，现在支持AVX系列指令集的处理器越来越多了。本文探讨如何用VC编写检测AVX系列指令集的程序，并利用了先前的CPUIDFIELD方案。 一、AVX系列指令集简介 　　SSE5 指令：SSE5 是一个纸面上的指令集，并没有最终实现，AMD 在 2007 年 8 月公布 SSE5 指令集规范，在 2009 年 5 月 AMD 推出了 XOP，...
AVX指令集是什么？（Advanced Vector Extensions 高级向量扩展）
Dontla的博客
02-12 1097
指令集是一种用于计算机处理器的扩展指令集，旨在提高处理器对矢量和浮点运算的支持能力。它是 Intel 在 2011 年发布的，并已得到许多。CPU 制造商的支持。AVX 指令集提供了 256 位的寄存器宽度，并且支持矢量化运算，从而可以在相同的时间内处理更多的数据。因此，AVX 指令集在数值计算、视频处理、生物信息学等领域有着广泛的应用。
AVX指令集函数列表中文翻译
weixin_50640987的博客
02-02 2709
基于Intel Intrinsics Guide 3.62，不包括AVX、AVX2中的以__mm开头的函数。本文档建议初学者学习，详细内容请查看官方文档。
汇编 AVX 传统SIMD ISA算术指令升级 -1
m0_73378754的博客
05-16 773
AVX将xmm1/m64中的一个双精度浮点值转换为一个扩展为r64的有符号四字整数符号。使用截断将xmm1/m64中的一个双精度浮点值转换为r32中的一位有符号双字整数。使用截断将xmm1/m64中的一个双精度浮点值转换为r32中的一位有符号双字整数。将ymm2/mem中的四个压缩双精度浮点值转换为xmm1中的四个子精度浮点值。使用截断将xmm1/m64中的一个双精度浮点值转换为r64中的有符号四字整数。将r/m64中的一个有符号四字整数转换为xmm1中的一位双精度浮点值。
关于指令集AVX AVX2学习笔记
m0_55063425的博客
01-08 7472
Intel指令集，适用于并行计算代码优化。Amd CPU也支持
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值