汇编 SSE2 指令简介

MOVAPD xmm2/m128, xmm1

Move aligned packed double precision floatingpoint values from xmm1 to xmm2/mem.

将xmm1 对齐的双精度浮点数打包mov 到xmm2/m128中

MOVUPD xmm2/m128, xmm1

Move unaligned packed double precision floatingpoint from xmm1 to xmm2/mem.

将xmm1 未对齐的双精度浮点数打包mov 到xmm2/m128中

MOVHPD xmm1, m64

Move double precision floating-point value from m64 to high quadword of xmm1.

将m64 中双精度浮点数mov 到xmm1 的高64位中(quadword:64位数据单元)

MOVLPD xmm1, m64

Move double precision floating-point value from m64 to low quadword of xmm1.

将m64 中双精度浮点数mov 到xmm1 的低64位中(quadword:64位数据单元)

MOVMSKPD reg, xmm

 Extract 2-bit sign mask from xmm and store in reg. The upper bits of r32 or r64 are filled with zeros.

从xmm中提取2位符号掩码并存储在reg中。r32或r64的高位用零填充。

DEST[0] := SRC[63]
DEST[1] := SRC[127]
IF DEST = r32
   THEN DEST[31:2] := 0;
   ELSE DEST[63:2] := 0;
FI

MOVSD xmm1, xmm2

        Move scalar double precision floating-point value from xmm2 to xmm1 register.

MOVSD xmm1,  m64

        Load scalar double precision floating-point value from m64 to xmm1 register.

ADDPD xmm1, xmm2/m128

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

相加成一个双精度浮点数保存到xmm1 中

DEST[63:0] := DEST[63:0] + SRC[63:0]

SUBSD xmm1, xmm2/m64

   Subtract the low double precision floating-point value in xmm2/m64 from xmm1 and store the result in xmm1.

   DEST[63:0] := DEST[63:0] – SRC[63:0]

MULPD xmm1, xmm2/m128

   Multiply packed double precision floating-point values in xmm2/m128 with xmm1 and store result in xmm1.
   DEST[63:0] := DEST[63:0] * SRC[63:0]
   DEST[127:64] := DEST[127:64] * SRC[127:64]

MULSD xmm1,xmm2/m64

     Multiply the low double precision floating-point value in xmm2/m64 by low double precision floating-point value  in xmm1.

    DEST[63:0] := DEST[63:0] * SRC[63:0]

 DIVPD xmm1, xmm2/m128

     Divide packed double precision floating-point values in xmm1 by packed double precision floating-point values in xmm2/mem.

DIVSD xmm1, xmm2/m64

       Divide low double precision floating-point value in xmm1 by low double precision floating-point value in xmm2/m64.

        DEST[63:0] := DEST[63:0] / SRC[63:0]

SQRTSD xmm1,xmm2/m64

MAXPD xmm1, xmm2/m128

        Return the maximum double precision floating-point values between xmm1 and xmm2/m128.
        DEST[63:0] := MAX(DEST[63:0], SRC[63:0])
        DEST[127:64] := MAX(DEST[127:64], SRC[127:64])

MAXSD xmm1, xmm2/m64

MINSD xmm1, xmm2/m64

        Return the minimum scalar double precision floating-point value between xmm2/m64 and xmm1.

        DEST[63:0] := MIN(SRC1[63:0], SRC2[63:0])

ANDNPD xmm1, xmm2/m128

CMP0 := SRC1[63:0] OP3 SRC2[63:0];
CMP1 := SRC1[127:64] OP3 SRC2[127:64];
IF CMP0 = TRUE  THEN

         DEST[63:0] := 0000000000000000H;

        DEST[127:64] := 0000000000000000H;

FI;

CMP0 := DEST[63:0] OP3 SRC[63:0];
IF CMP0 = TRUE
THEN

        DEST[63:0] := 0000000000000000H;

FI;

将两个双精度浮点数进行比较，并根据比较结果设置处理器标志位（flags），

RESULT := OrderedCompare(DEST[63:0] <> SRC[63:0]) {

(* Set EFLAGS *) CASE (RESULT) OF
        UNORDERED: ZF,PF,CF := 111;
        GREATER_THAN: ZF,PF,CF := 000;
        LESS_THAN: ZF,PF,CF := 001;
        EQUAL: ZF,PF,CF := 100;
        ESAC; OF, AF, SF := 0;

}

RESULT := UnorderedCompare(DEST[63:0] <> SRC[63:0]) {

(* Set EFLAGS *) CASE (RESULT) OF
        UNORDERED: ZF,PF,CF := 111;
        GREATER_THAN: ZF,PF,CF := 000;
        LESS_THAN: ZF,PF,CF := 001;
        EQUAL: ZF,PF,CF := 100;
        ESAC;
OF, AF, SF := 0;

}

使用imm8对xmm1和xmm2/m128中的两对双精度浮点值进行乱序处理，从每对值中进行选择，交织后的结果存储在xmm1中。

xmm1[0:63] 的值从 xmm1 根据imm8 [0:1] 选择哪个单精度的值

mm1[64:127] 的值从 xmm2/m 根据imm8 [2:3] 选择哪个单精度的值

UNPCKHPD xmm1, xmm2/m128

UNPCKLPD xmm1, xmm2/m128
        Unpacks and Interleaves double precision floating-point 
values from low quadwords of xmm1 and xmm2/m128.

CVTPD2PI mm, xmm/m128

  Convert two packed double precision floatingpoint values from xmm/m128 to two packed signed doubleword integers in mm.

寄存器中的双精度浮点数转换为带符号整数，并将结果存储到mm寄存器中

DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer32(SRC[63:0]);
DEST[63:32] := Convert_Double_Precision_Floating_Point_To_Integer32(SRC[127:64]);

注: 双精度的浮点数，整数部分12位(1个符号位(最高位)，11位整数(52~63))

CVTTPD2PI mm, xmm/m128

将xmm寄存器中的双精度浮点数向零舍入转换为带符号整数，并将结果存储到mm寄存器中

注: 双精度的浮点数，整数部分12位(1个符号位(最高位)，11位整数(52~63))

CVTPD2DQ xmm1, xmm2/m128

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

将xmm2/m128寄存器中的打包双精度浮点值转换为xmm1寄存器中的打包双字整数

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[127:64] := 0

CVTTPD2DQ 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）中的双字整数。在进行转换时，会将双精度浮点数朝零舍入后存储为双字整数
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[127:64] := 0

CVTDQ2PD xmm1, xmm2/m64

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

将xmm2/m64寄存器中的双字整数（32位有符号整数）转换为xmm1寄存器中的打包双精度浮点值

将源操作数（xmm2/m64）中的打包单精度浮点值转换为目标操作数（xmm1）中的打包双精度浮点值。在进行转换时，会扩展单精度浮点值的精度后存储为双精度浮点值

CVTPD2PS xmm1, xmm2/m128

将源操作数（xmm2/m128）中的打包双精度浮点值转换为目标操作数（xmm1）中的打包单精度浮点值。在进行转换时，会截断双精度浮点值的精度后存储为单精度浮点值

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[127:64] := 0

将xmm2/m32寄存器中的标量单精度浮点值转换为xmm1寄存器中的标量双精度浮点值

CVTSD2SS xmm1, xmm2/m64

        Convert one double precision floating-point value in xmm2/m64 to one single precision floating-point value in xmm1.

用于将源操作数（xmm2/m64）中的标量双精度浮点值转换为目标操作数（xmm1）中的标量单精度浮点值,这个指令实现了将双精度浮点值转换为单精度浮点值的功能

        1: Convert one double precision floating-point value from xmm1/m64 to one signed doubleword integer r32.

                将xmm1/m64中的一个双精度浮点值转换为一个有符号双字整数r32。

        2: Convert one double precision floating-point value from xmm1/m64 to one signed quadword integer sign extended into r64.

                将双精度浮点值xmm1/m64转换为一个扩展到r64中的有符号四字整数符号。

IF 64-Bit Mode and OperandSize = 64 THEN
        DEST[63:0] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[63:0]);
ELSE
        DEST[31:0] := Convert_Double_Precision_Floating_Point_To_Integer(SRC[63:0]);
FI;

        1: Convert one signed doubleword integer from r32/m32 to one double precision floating-point value in xmm1.

                将r32/m32的一个有符号双字整数转换为xmm1中的一个双精度浮点值

        2: Convert one signed quadword integer from r/m64  to one double precision floating-point value in xmm1.

                将r/m64中的一个有符号四字整数转换为xmm1中的一位双精度浮点值。

IF 64-Bit Mode And OperandSize = 64
THEN
DEST[63:0] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[63:0]);
ELSE
DEST[63:0] := Convert_Integer_To_Double_Precision_Floating_Point(SRC[31:0]);
FI;

将xmm2/m128寄存器中的双字整数（32位有符号整数）转换为xmm1寄存器中的单精度浮点值

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)

CVTPS2DQ xmm1, xmm2/m128

将源操作数（xmm2/m128）中的打包单精度浮点值转换为目标操作数（xmm1）中的打包双字整数。这个指令实现了将单精度浮点值转换为有符号整数的功能，

 默认：四舍五入后存储为整数

4个单精度浮点数 转为 4个整数 

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])

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

截断转换方式取整

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[127:0] := SRC[127:0]

MOVQ2DQ xmm, mm

Move quadword from mmx to low quadword of xmm.

 MOVDQ2Q mm, xmm
       Move low quadword from xmm to mmx register.
       DEST := SRC[63:0];

PMULUDQ mm1, mm2/m64

        Multiply unsigned doubleword integer in mm1 by unsigned doubleword integer in mm2/m64, and  store the quadword result in mm1.

       DEST[63:0] := DEST[31:0] ∗ SRC[31:0];

PMULUDQ xmm1, xmm2/m128

        Multiply packed unsigned doubleword integers in xmm1 by packed unsigned doubleword integers  in xmm2/m128, and store the quadword results in xmm1.

PADDD xmm1, xmm2/m128

 Add packed doubleword integers from xmm2/m128 and xmm1.

执行打包的32位整数加法操作

PADDW xmm1, xmm2/m128

Add packed word integers from xmm2/m128 and 

DEST[15:0] := DEST[15:0] + SRC[15:0];
(* Repeat add operation for 2nd and 3th word *)
DEST[63:48] := DEST[63:48] + SRC[63:48];

PADDB xmm1, xmm2/m128

 Add packed byte integers from xmm2/m128 and xmm1.

将源操作数（xmm2/m128）中的每个字节与目标操作数（xmm1）中对应的字节相加，并将结果存储在目标操作数中

DEST[7:0] := DEST[7:0] + SRC[7:0]; 
(* Repeat add operation for 2nd through 7th byte *)
DEST[63:56] := DEST[63:56] + SRC[63:56]

PADDQ xmm1, xmm2/m128

 Add packed quadword integers from xmm2/m128 and xmm1.

打包的64位整数加法操作

DEST[63:0] := DEST[63:0] + SRC[63:0];

PSUBQ mm1, mm2/m64

   Subtract packed quadword integers in xmm1 from xmm2 /m128.
           DEST[63:0] := DEST[63:0] − SRC[63:0];
           DEST[127:64] := DEST[127:64] − SRC[127:64];

PSHUFLW xmm1, xmm2/m128, imm8

        Shuffle the low words in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

根据imm8参数指定的掩码对源操作数（xmm2/m128）的低64位进行重新排列，然后将结果存储在目标操作数（xmm1）中

当XMM0 = 22222 3333 4444 5555 6666 h
XMM1 = 66666 7777 8888 9999 cccc h,

根据imm8参数指定的掩码对128位XMM寄存器的高64位进行重新排列，然后将结果存储在目标操作数中

PSHUFD xmm1, xmm2/m128, imm8

        Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and store the result in xmm1.

根据imm8参数指定的掩码对源操作数（xmm2/m128）中的32位整数进行重新排列，并将结果存储在目标操作数（xmm1）中。

用于对XMM寄存器xmm1中的128位值执行逻辑左移操作。移位量由imm8立即数指定，范围从0到15

        TEMP := 16;

FI
DEST := DEST << (TEMP * 8)
 

用于对XMM寄存器xmm1中的128位值执行逻辑右移操作。移位量由imm8立即数指定，范围从0到15

        TEMP := 16;

PUNPCKLQDQ xmm1, xmm2/m128 

        Interleave low-order quadword from xmm1 and xmm2/m128 into xmm1 register.

它将源操作数（xmm2/m128）和目标操作数（xmm1）的低四分之一部分交错排列，并将结果存储在xmm1中

PUNPCKLDQ xmm1, xmm2/m128

        Interleave low-order doublewords from xmm1 and xmm2/m128 into xmm1.

源操作数（xmm2/m128）和目标操作数（xmm1）的低双字部分交错排列，并将结果存储在xmm1中

CLFLUSH m8

 Flushes cache line containing m8.

将缓存行（cache line）中的数据写回内存并使其无效，

通常用于特定的系统编程场景

 Serializes load operations.

确保在LFENCE之前的所有加载操作都已完成。它是一个轻量级的内存屏障指令，通常用于确保在其之前的加载操作不会受到乱序执行的影响

 Serializes load and store operations.

确保在MFENCE之前和之后的内存访问操作都已完成

暂停:

向处理器发出一个暗示，告诉处理器当前线程正在忙等待，并且可以让处理器在这种情况下进行一些内部优化，以减少功耗和提高性能

通常用于编写自旋锁等需要忙等待的同步原语时，以改善系统的性能和效率。

根据xmm2寄存器中的掩码条件性地将xmm1寄存器中的128位值写入内存,

xmm2寄存器中的掩码决定了从xmm1寄存器中哪些字节被写入内存。这个指令对于根据掩码选择性地将数据写入内存非常有用

IF (MASK[7] = 1) THEN

         DEST[DI/EDI] := SRC[7:0]

ELSE

         (* Memory location unchanged *);

        DEST[DI/EDI +1] := SRC[15:8]

ELSE

        (* Memory location unchanged *);

FI;
(* Repeat operation for 3rd through 14th bytes in source operand *)
IF (MASK[127] = 1) THEN

        DEST[DI/EDI +15] := SRC[127:120]

ELSE

         (* Memory location unchanged *);

FI;

用于将xmm1寄存器中的非临时打包双精度浮点值移动到由m128操作数指定的内存位置

MOVNTDQ m128, xmm1

Move packed integer values in xmm1 to m128 using nontemporal hint.

用于将xmm1寄存器中的非临时双四字（128位）数据移动到由m128操作数指定的内存位置

将r32寄存器中的32位值移动到由m32操作数指定的内存位置，

数据应直接写入内存，而不缓存在处理器的缓存层次结构中