汇编 AVX 算术指令 简介

最新推荐文章于 2024-05-31 13:59:14 发布
最新推荐文章于 2024-05-31 13:59:14 发布
阅读量910 收藏 16
点赞数 23
文章标签： 汇编
版权声明：本文为博主原创文章，遵循 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值: 

程序猴--小川
关注
  • 23
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
51汇编之算术运算类指令
11-25
测透51汇编 12864液晶显示 每条指令都验证过 都没有问题 为了纪念过去的劳作
使用avx2指令集实现的strlen函数
12-25
使用AVX2指令集实现的strlen函数，一般情况下较新的CPU都支持avx2指令集，使用avx2指令集可以加快程序的运行速度
AVX指令集介绍
jiangxing11的博客
09-20 1972
最近在学习指令集相关知识，刚好来练练手。在正式应用前首先看一段代码吧这段代码很容易理解，依次将各点进行x2y2z2计算，然后赋值给矩阵mB。那么变成AVX指令集加速版本应该是这样的。这段代码中出现了好几个关键的指令集方法，第一次看这个我也是懵逼状态。不过查阅了手册后，很快便能理解AVX指令的一些规则。
汇编 AVX 传统SIMD ISA算术指令升级 -1
m0_73378754的博客
05-16 715
AVX将xmm1/m64中的一个双精度浮点值转换为一个扩展为r64的有符号四字整数符号。使用截断将xmm1/m64中的一个双精度浮点值转换为r32中的一位有符号双字整数。使用截断将xmm1/m64中的一个双精度浮点值转换为r32中的一位有符号双字整数。将ymm2/mem中的四个压缩双精度浮点值转换为xmm1中的四个子精度浮点值。使用截断将xmm1/m64中的一个双精度浮点值转换为r64中的有符号四字整数。将r/m64中的一个有符号四字整数转换为xmm1中的一位双精度浮点值。
汇编指令集合
maryhaocoolcool的博客
11-15 3829
汇编语言cs：是代码段寄存器，ds是数据段寄存器。 段代码CS：存放当前正在运行的程序代码所在段的段基值，表示当前使用的指令代码可以从该段寄存器指定的存储器段中取得 IP：相应的偏移值。 CS+IP 1. call word ptr + 内存单元地址 这个指令的是先将call指令的下一条指令的IP入栈，然后跳到以内存单元地址为IP的代码处 2.call dword ptr + 内存单元地址 call是汇编指令，用来调用子过程。后面的Dword ptr[40105c]是一个内存地址，就是要调用的子过
C/C++汇编学习（三）——指令集-汇编基础
Bobowen的博客
01-04 1733
汇编语言允许程序员直接操控硬件，理解和操作处理器的内部机制。这在系统编程、嵌入式系统、操作系统开发等领域非常重要。不过，由于汇编语言高度依赖于具体的硬件架构，因此通常不如高级语言（如C++或Python）那样具有可移植性。
avx2入门
DuoKingg的博客
03-11 2012
avx2入门
一文读懂SIMD指令集 目前最全SSE/AVX介绍
热门推荐
rqX的博客
06-06 3万+
SIMD指令集 SSE/AVX 概述 参考手册 Intel® Intrinsics Guide Tommesani.com Docs Intel® 64 and IA-32 Architectures Software Developer Manuals 背景 1. 什么是指令集 所谓指令集，就是CPU中用来计算和控制计算机系统的一套指令的集合，而每一种新型的CPU在设计时就规定了一系列与其他硬件电路相配合的指令系统。而指令集的先进与否，也关系到CPU的性能发挥，它也是CPU性能体现的一个重
汇编指令发展历程
专注HEVC，H.264，ffmpeg
11-21 706
源地址：http://blog.csdn.net/qingkong8832/article/details/6797422
指令集简介
u010154760的专栏
04-11 1064
指令集或指令集体系：是计算机体系结构中与程序设计有关的部分，包含了基本数据类型、指令集、寄存器、寻址模式、中断、异常处理以及外部的I/O。指令集架构包含一系列的opcode即操作码(机器语言)，以及由特定处理器执行的基本命令。          指令集的分类：(1)、复杂指令集计算机包含许多应用程序中很少使用的特定指令；(2)、精简指令集计算机通过只执行在程序中经常使用的指令来简化处理器的结
SSE 指令集
泠山的博客
09-01 892
这是一个typedef语句，它创建了一个新的数据类型别名__m128_u，它被定义为float类型。: 这是GCC（GNU Compiler Collection）的属性语法，用于为__m128_u类型添加一些属性。(16): 这个属性指定了该类型的大小为 16 字节（128位），这使得 __m128_u 可以在一个128位寄存器中存储。may_alias: 这个属性告诉编译器，指针类型可以别名为 __m128_u，这是因为这种类型的别名可能会导致一些类型别名的规则和内存别名的优化问题。
汇编指令查询器 汇编指令查询器
06-25
汇编指令查询器 汇编指令查询器 汇编指令查询器 汇编指令查询器 汇编指令查询器 汇编指令查询器 汇编指令查询器
汇编语言指令大全资源合集
06-12
汇编语言指令大全 汇编语言(assembly language)是一种用于电子计算机、微处理器、微控制器或其他可编程器件的低级语言,亦称为符号语言。在汇编语言中,用助记符(Mnemonics)代替机器指令的操作码,用地址符号(Symbol)或...
aarch64 完整汇编指令集
07-08
aarch64 完整汇编指令集，包括基础指令, SIMD, SVE, SME 指令共1650 多条
汇编：循环结构
WolvenSec的博客
05-28 752
16位汇编语言中的循环结构主要通过条件跳转指令（如、, , , , , 等）来实现，常见的循环类型包括循环和循环；指令的操作非常简单：它将CX寄存器的值减1，如果结果不为零，则跳转到指定的标签。这使得它特别适用于已知循环次数的情况，比如循环。 是一个标签，指向循环的开始位置。 将寄存器 设置为 9，表示将从9开始循环。：将 的值复制到 寄存器。：将 的值加上 。在ASCII码表中，数字字符'0'的值是0x30，所以加上0x30可以将0-9的数字转换为'0'-'9'的ASCII字符。：将
汇编：调用C函数
最新发布
WolvenSec的博客
05-31 480
在32位汇编程序中可以调用C函数；这种做法在很多情况下是有用的，尤其是在汇编程序需要与C代码进行交互或利用C语言的库函数时。②系统调用：在汇编中，系统调用是通过软中断（int 0x80）来执行的，一些系统调用需要更复杂的参数传递和处理，这时可以使用C函数来简化处理。③特殊硬件的访问：在一些特殊的硬件平台上，需要用到特定的C库函数来进行底层硬件访问。②调用C函数：使用适当的调用约定（例如stdcall）来调用C函数，并正确传递参数。①声明C函数：在汇编程序中声明C函数，以便汇编器知道函数的名称和参数类型。
汇编原理（四）[BX]和loop指令
xxlyss的博客
05-28 314
误区：在编译器里写代码和在debug里写代码是不一样的，此时，对于编译器来说，就需要用到[bx][bx]同样表示一个内存单元，他的偏移地址在bx中，比如下面的指令。
汇编原理 | 二进制、跳转指令、算数运算、
xxlyss的博客
05-28 436
JB/JNAE/JC - jump if below/not above equal/carry 低于/不高于等于/有借位。在32位bit时该怎么表示-6？-> 111...(20个1) 1101 (十进制里的13/d) 0110(十进制里的6) 0110(十进制里的6)-> 000...(20个0) 0010(十进制里的2) 1001(十进制里的9) 1010(十进制里的a)a-Above、g-Greater 当操作数1 > 操作数2 时发生跳转。-1 = 1111（由 1 + （-1） = 0 推的）
51单片机汇编语言算术运算指令
10-11
51单片机汇编语言中常用的算术运算指令有ADD、SUB、INC、DEC、MUL和DIV等。 其中，ADD指令用于两个操作数的加法运算；SUB指令用于两个操作数的减法运算；INC指令用于将一个操作数加1；DEC指令用于将一个操作数减1；...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值