汇编 intel SSSE3 指令简介

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

简介: 它是SSE3（Streaming SIMD Extensions 3）的补充，引入了一些额外的指令，用于加速多媒体和向量化计算。SSSE3指令集提供了一些新的指令，例如平行比较、平行加减运算、逐位平行操作等，可以帮助优化处理多媒体数据和执行向量化计算任务。这些指令能够提高程序的性能和效率，特别是在涉及大量数据并行处理的情况下。

水平加法/减法
PHADDW

PHADDW mm1, mm2/m64

        Add 16-bit integers horizontally, pack to mm1.

        将两个操作数相加，并将结果存储在mm1寄存器中。

        这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着16位的数据。

PHADDW xmm1, xmm2/m128

        Add 16-bit integers horizontally, pack to xmm1.

        将两个操作数相加，并将结果存储在xmm1寄存器中。

        这里的xmm1和xmm2/m64表示寄存器或内存位置，分别存储着16位的数据。

PHADDW执行的是带符号的16位整数加法操作。

PHADDW (With 64-bit Operands)
    mm1[15-0] = mm1[31-16] + mm1[15-0]; 
    mm1[31-16] = mm1[63-48] + mm1[47-32]; 
    mm1[47-32] = mm2/m64[31-16] + mm2/m64[15-0]; 
    mm1[63-48] = mm2/m64[63-48] + mm2/m64[47-32]; 
PHADDW (With 128-bit Operands)
    xmm1[15-0] = xmm1[31-16] + xmm1[15-0]; 
    xmm1[31-16] = xmm1[63-48] + xmm1[47-32]; 
    xmm1[47-32] = xmm1[95-80] + xmm1[79-64]; 
    xmm1[63-48] = xmm1[127-112] + xmm1[111-96]; 
    xmm1[79-64] = xmm2/m128[31-16] + xmm2/m128[15-0]; 
    xmm1[95-80] = xmm2/m128[63-48] + xmm2/m128[47-32]; 
    xmm1[111-96] = xmm2/m128[95-80] + xmm2/m128[79-64]; 
    xmm1[127-112] = xmm2/m128[127-112] + xmm2/m128[111-96];

PHADDSW

PHADDSW mm1, mm2/m64
        Add 16-bit signed integers horizontally, pack saturated integers to mm1.

        将两个操作数相加，并将结果存储在mm1寄存器中。

        这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着16位的数据。
PHADDSW xmm1, xmm2/m128
        Add 16-bit signed integers horizontally, pack saturated integers to xmm1.

        用于将两个操作数相加，并将结果存储在XMM寄存器中。

        这里的xmm1和xmm2/m128表示寄存器或内存位置，分别存储着16位的数据

PHADDSW执行的是带符号的16位整数加法操作。

PHADDSW (With 64-bit Operands)
    mm1[15-0] = SaturateToSignedWord((mm1[31-16] + mm1[15-0]); 
    mm1[31-16] = SaturateToSignedWord(mm1[63-48] + mm1[47-32]);
    mm1[47-32] = SaturateToSignedWord(mm2/m64[31-16] + mm2/m64[15-0]); 
    mm1[63-48] = SaturateToSignedWord(mm2/m64[63-48] + mm2/m64[47-32]);

PHADDSW (With 128-bit Operands)
    xmm1[15-0]= SaturateToSignedWord(xmm1[31-16] + xmm1[15-0]);
    xmm1[31-16] = SaturateToSignedWord(xmm1[63-48] + xmm1[47-32]);
    xmm1[47-32] = SaturateToSignedWord(xmm1[95-80] + xmm1[79-64]);
    xmm1[63-48] = SaturateToSignedWord(xmm1[127-112] + xmm1[111-96]); 
    xmm1[79-64] = SaturateToSignedWord(xmm2/m128[31-16] + xmm2/m128[15-0]);
    xmm1[95-80] = SaturateToSignedWord(xmm2/m128[63-48] + xmm2/m128[47-32]);
    xmm1[111-96] = SaturateToSignedWord(xmm2/m128[95-80] + xmm2/m128[79-64]);
    xmm1[127-112] = SaturateToSignedWord(xmm2/m128[127-112] + xmm2/m128[111-96]);

PHADDD

PHADDD xmm1, xmm2/m128

        Add 32-bit integers horizontally, pack to xmm1.

        将两个操作数相加，并将结果存储在XMM寄存器中。这里的XMM表示128位的寄存器，

PHADDD mm1, mm2/m64
         Add 32-bit integers horizontally, pack to mm1.

        将两个操作数相加，并将结果存储在MM寄存器中。这里的MM表示64位的寄存器，

PHADDD执行的是带符号的32位整数加法操作。

PHADDD (With 64-bit Operands)
    mm1[31-0] = mm1[63-32] + mm1[31-0]; 
    mm1[63-32] = mm2/m64[63-32] + mm2/m64[31-0]; 
PHADDD (With 128-bit Operands)
    xmm1[31-0] = xmm1[63-32] + xmm1[31-0]; 
    xmm1[63-32] = xmm1[127-96] + xmm1[95-64]; 
    xmm1[95-64] = xmm2/m128[63-32] + xmm2/m128[31-0]; 
    xmm1[127-96] = xmm2/m128[127-96] + xmm2/m128[95-64];

PHSUBW

PHSUBW mm1, mm2/m64

         Subtract 16-bit signed integers horizontally, pack to mm1. 

        指令用于将两个操作数相减，并将结果存储在mm1寄存器中。

        这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着16位的数据。

PHSUBW xmm1, xmm2/m128
         Subtract 16-bit signed integers horizontally, pack to xmm1. 

        将两个操作数相减，并将结果存储在XMM寄存器中。

        这里的xmm1和xmm2/m128表示寄存器或内存位置，分别存储着16位的数据

PHSUBW执行的是带符号的16位整数减法操作

PHSUBW (With 64-bit Operands) 
    mm1[15-0] = mm1[15-0] - mm1[31-16]; 
    mm1[31-16] = mm1[47-32] - mm1[63-48]; 
    mm1[47-32] = mm2/m64[15-0] - mm2/m64[31-16];
    mm1[63-48] = mm2/m64[47-32] - mm2/m64[63-48]; 
PHSUBW (With 128-bit Operands)
    xmm1[15-0] = xmm1[15-0] - xmm1[31-16]; 
    xmm1[31-16] = xmm1[47-32] - xmm1[63-48]; 
    xmm1[47-32] = xmm1[79-64] - xmm1[95-80]; 
    xmm1[63-48] = xmm1[111-96] - xmm1[127-112]; 
    xmm1[79-64] = xmm2/m128[15-0] - xmm2/m128[31-16]; 
    xmm1[95-80] = xmm2/m128[47-32] - xmm2/m128[63-48]; 
    xmm1[111-96] = xmm2/m128[79-64] - xmm2/m128[95-80]; 
    xmm1[127-112] = xmm2/m128[111-96] - xmm2/m128[127-112]

PHSUBSW

PHSUBSW mm1, mm2/m64

        Subtract 16-bit signed integer horizontally, pack saturated integers to mm1.

        用于将两个操作数相减，并将结果存储在mm1寄存器中。

        这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着16位的数据。

PHSUBSW xmm1, xmm2/m128

         Subtract 16-bit signed integer horizontally, pack saturated integers to xmm1.

        用于将两个操作数相减，并将结果存储在XMM寄存器中。

        这里的xmm1和xmm2/m128表示寄存器或内存位置，分别存储着16位的数据

PHSUBSW执行的是带符号的16位整数减法操作。

PHSUBSW (With 64-bit Operands)
    mm1[15-0] = SaturateToSignedWord(mm1[15-0] - mm1[31-16]); 
    mm1[31-16] = SaturateToSignedWord(mm1[47-32] - mm1[63-48]);
    mm1[47-32] = SaturateToSignedWord(mm2/m64[15-0] - mm2/m64[31-16]); 
    mm1[63-48] = SaturateToSignedWord(mm2/m64[47-32] - mm2/m64[63-48]);

PHSUBSW (With 128-bit Operands)
    xmm1[15-0] = SaturateToSignedWord(xmm1[15-0] - xmm1[31-16]); 
    xmm1[31-16] = SaturateToSignedWord(xmm1[47-32] - xmm1[63-48]);
    xmm1[47-32] = SaturateToSignedWord(xmm1[79-64] - xmm1[95-80]);
    xmm1[63-48] = SaturateToSignedWord(xmm1[111-96] - xmm1[127-112]);
    xmm1[79-64] = SaturateToSignedWord(xmm2/m128[15-0] - xmm2/m128[31-16]); 
    xmm1[95-80] =SaturateToSignedWord(xmm2/m128[47-32] - xmm2/m128[63-48]); 
    xmm1[111-96] =SaturateToSignedWord(xmm2/m128[79-64] - xmm2/m128[95-80]);
    xmm1[127-112]= SaturateToSignedWord(xmm2/m128[111-96] - xmm2/m128[127-112]);

PHSUBD

PHSUBD mm1, mm2/m64
         Subtract 32-bit signed integers horizontally, pack to mm1. 

        将两个操作数相减，并将结果存储在mm1寄存器中。

        这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着32位的数据。


PHSUBD xmm1, xmm2/m128 
         Subtract 32-bit signed integers horizontally, pack to xmm1.

        用于将两个操作数相减，并将结果存储在XMM寄存器中。

        这里的xmm1和xmm2/m128表示寄存器或内存位置，分别存储着32位的数据

PHSUBD执行的是带符号的32位整数减法操作。

PHSUBD (With 64-bit Operands)
    mm1[31-0] = mm1[31-0] - mm1[63-32];
    mm1[63-32] = mm2/m64[31-0] - mm2/m64[63-32];
PHSUBD (With 128-bit Operands)
    xmm1[31-0] = xmm1[31-0] - xmm1[63-32]; 
    xmm1[63-32] = xmm1[95-64] - xmm1[127-96]; 
    xmm1[95-64] = xmm2/m128[31-0] - xmm2/m128[63-32]; 
    xmm1[127-96] = xmm2/m128[95-64] - xmm2/m128[127-96];

Packed Absolute Values
PABSB

PABSB mm1, mm2/m64 
             Compute the absolute value of bytes in mm2/m64 and store UNSIGNED result in            mm1.

                将mm2/m64寄存器或内存位置中的8位带符号整数取绝对值，

                并将结果存储在mm1寄存器中

PABSB xmm1, xmm2/m128 
            Compute the absolute value of bytes in xmm2/m128 and store UNSIGNED result in         xmm1. 

                将xmm2/m128寄存器或内存位置中的8位带符号整数取绝对值，

                并将结果存储在xmm1寄存器中

PABSB With 64-bit Operands:
    Unsigned DEST[7:0] := ABS(SRC[7: 0]) 
    Repeat operation for 2nd through 7th bytes 
    Unsigned DEST[63:58] := ABS(SRC[63:58])


PABSB With 128-bit Operands:
    Unsigned DEST[7:0] := ABS(SRC[7: 0]) 
    Repeat operation for 2nd through 15th bytes 
    Unsigned DEST[127:120] := ABS(SRC[127:120])

PABSW

PABSW mm1, mm2/m64 
           Compute the absolute value of 16-bit integers in mm2/m64 and store UNSIGNED         result in mm1.

               将mm2/m64寄存器或内存位置中的16位带符号整数取绝对值，

                并将结果存储在mm1寄存器中

PABSW xmm1, xmm2/m128
             Compute the absolute value of 16-bit integers in xmm2/m128 and store UNSIGNED          result in xmm1.

                将xmm2/m128寄存器或内存位置中的16位带符号整数取绝对值，

                并将结果存储在xmm1寄存器中

   PABSW With 64-bit Operands:
    Unsigned DEST[15:0] := ABS(SRC[15:0]) 
    Repeat operation for 2nd through 3th 16-bit words 
    Unsigned DEST[63:48] := ABS(SRC[63:48])

PABSW With 128-bit Operands:
    Unsigned DEST[15:0] := ABS(SRC[15:0]) 
    Repeat operation for 2nd through 7th 16-bit words 
    Unsigned DEST[127:112] := ABS(SRC[127:112])

PABSSD

PABSD mm1, mm2/m64 
              Compute the absolute value of 32-bit integers in mm2/m64 and store UNSIGNED          result in mm1. 

                将mm2/m64寄存器或内存位置中的32位带符号整数取绝对值，

                并将结果存储在mm1寄存器中。

PABSD xmm1, xmm2/m128 
             Compute the absolute value of 32-bit integers in xmm2/m128 and store UNSIGNED         result in xmm1

                将xmm2/m128寄存器或内存位置中的32位带符号整数取绝对值，

                并将结果存储在xmm1寄存器中

PABSD With 64-bit Operands:
    Unsigned DEST[31:0] := ABS(SRC[31:0]) 
    Unsigned DEST[63:32] := ABS(SRC[63:32])

PABSD With 128-bit Operands:
    Unsigned DEST[31:0] := ABS(SRC[31:0]) 
    Repeat operation for 2nd through 3rd 32-bit double words 
    Unsigned DEST[127:96] := ABS(SRC[127:96])

Multiply and Add Packed Signed and Unsigned Bytes
PMADDUBSW

PMADDUBSW mm1, mm2/m64
          Multiply signed and unsigned bytes, add horizontal pair of signed words, pack 
        saturated signed-words to mm1.

                用于将两个操作数进行乘法和加法运算，

                并将结果存储在mm1寄存器中。

                这里的mm1和mm2/m64表示寄存器或内存位置，分别存储着8位的数据。
PMADDUBSW xmm1, xmm2/m128
           Multiply signed and unsigned bytes, add horizontal pair of signed words, pack 
        saturated signed-words to xmm1.

                将两个操作数进行乘法和加法运算，并将结果存储在XMM寄存器中。

                这里的xmm1和xmm2/m128表示寄存器或内存位置，分别存储着8位的数据

PMADDUBSW执行的是带符号的8位整数乘法和加法操作。

PMADDUBSW (With 64-bit Operands)
    DEST[15-0] = SaturateToSignedWord(SRC[15-8]*DEST[15-8]+SRC[7-0]*DEST[7-0]);
    DEST[31-16] = SaturateToSignedWord(SRC[31-24]*DEST[31-24]+SRC[23-16]*DEST[23-16]);
    DEST[47-32] = SaturateToSignedWord(SRC[47-40]*DEST[47-40]+SRC[39-32]*DEST[39-32]);
    DEST[63-48] = SaturateToSignedWord(SRC[63-56]*DEST[63-56]+SRC[55-48]*DEST[55-48]);


PMADDUBSW (With 128-bit Operands)
    DEST[15-0] = SaturateToSignedWord(SRC[15-8]* DEST[15-8]+SRC[7-0]*DEST[7-0]);
    // Repeat operation for 2nd through 7th word 
    SRC1/DEST[127-112] = SaturateToSignedWord(SRC[127-120]*DEST[127-120]+ SRC[119-112]* DEST[119-112]);

Packed Multiply High with Round and Scale:
PMULHRSW

PMULHRSW mm1, mm2/m64
            Multiply 16-bit signed words, scale and round signed doublewords,

            pack high 16 bits to mm1.

将两个操作数进行带符号16位整数乘法，并将结果存储在mm1寄存器中。
PMULHRSW xmm1, xmm2/m128
            Multiply 16-bit signed words, scale and round signed doublewords,

                 pack high 16 bits to xmm1.

将两个操作数进行带符号16位整数乘法，并将结果存储在XMM寄存器中。

PMULHRSW (With 64-bit Operands)
	temp0[31:0] = INT32 ((DEST[15:0] * SRC[15:0]) >>14) + 1;
	temp1[31:0] = INT32 ((DEST[31:16] * SRC[31:16]) >>14) + 1;
	temp2[31:0] = INT32 ((DEST[47:32] * SRC[47:32]) >> 14) + 1;
	temp3[31:0] = INT32 ((DEST[63:48] * SRc[63:48]) >> 14) + 1;
	DEST[15:0] = temp0[16:1];
	DEST[31:16] = temp1[16:1];
	DEST[47:32] = temp2[16:1];
	DEST[63:48] = temp3[16:1];
PMULHRSW (With 128-bit Operands)
	temp0[31:0] = INT32 ((DEST[15:0] * SRC[15:0]) >>14) + 1;
	temp1[31:0] = INT32 ((DEST[31:16] * SRC[31:16]) >>14) + 1;
	temp2[31:0] = INT32 ((DEST[47:32] * SRC[47:32]) >>14) + 1;
	temp3[31:0] = INT32 ((DEST[63:48] * SRC[63:48]) >>14) + 1;
	temp4[31:0] = INT32 ((DEST[79:64] * SRC[79:64]) >>14) + 1;
	temp5[31:0] = INT32 ((DEST[95:80] * SRC[95:80]) >>14) + 1;
	temp6[31:0] = INT32 ((DEST[111:96] * SRC[111:96]) >>14) + 1;
	temp7[31:0] = INT32 ((DEST[127:112] * SRC[127:112) >>14) + 1;
	DEST[15:0] = temp0[16:1];
	DEST[31:16] = temp1[16:1];
	DEST[47:32] = temp2[16:1];
	DEST[63:48] = temp3[16:1];
	DEST[79:64] = temp4[16:1];
	DEST[95:80] = temp5[16:1];
	DEST[111:96] = temp6[16:1];
	DEST[127:112] = temp7[16:1];

Packed Shuffle Bytes:
PSHUFB

PSHUFB mm1, mm2/m64
        Shuffle bytes in mm1 according to contents of mm2/m64.

        根据mm2/m64寄存器或内存位置中的内容对mm1寄存器中的数据进行按位重新排列
PSHUFB xmm1, xmm2/m128
        Shuffle bytes in xmm1 according to contents of xmm2/m128.

     根据xmm2/m128寄存器或内存位置中的内容对xmm1寄存器中的数据进行按位重新排列。

PSHUFB (With 64-bit Operands)
    TEMP := DEST
        for i = 0 to 7 { 
        if (SRC[(i * 8)+7] = 1 ) then
                DEST[(i*8)+7...(i*8)+0] := 0;
        else 
                index[2..0] := SRC[(i*8)+2 .. (i*8)+0];
                DEST[(i*8)+7...(i*8)+0] := TEMP[(index*8+7)..(index*8+0)];
        endif;
    }
PSHUFB (with 128 bit operands)
    TEMP := DEST
    for i = 0 to 15 { 
    if (SRC[(i * 8)+7] = 1 ) then
            DEST[(i*8)+7..(i*8)+0] := 0;
     else 
    index[3..0] := SRC[(i*8)+3 .. (i*8)+0];
            DEST[(i*8)+7..(i*8)+0] := TEMP[(index*8+7)..(index*8+0)];
    endif
    }

Packed Sign:
def byte_sign(control, input_val):
     if control<0:
     return negate(input_val)
     elif control==0:
     return 0
     return input_val
 
def word_sign(control, input_val):
     if control<0:
     return negate(input_val)
     elif control==0:
     return 0
     return input_val
 
def dword_sign(control, input_val):
     if control<0:
     return negate(input_val)
     elif control==0:
     return 0
     return input_val

PSIGNB

PSIGNB mm1, mm2/m64

           Negate/zero/preserve packed byte integers in mm1 depending on

        the corresponding  sign in mm2/m64.

将mm1寄存器中的每个字节(8位)根据mm2/m64寄存器或内存位置中的符号位进行取值。如果mm2/m64中对应字节的符号位为0，则结果字节取正值；如果mm2/m64中对应字节的符号位为1，则结果字节取负值。

PSIGNB xmm1, xmm2/m128
          Negate/zero/preserve packed byte integers in xmm1 depending on

        the corresponding sign in xmm2/m128.

将xmm1寄存器中的每个字节(8位)根据xmm2/m128寄存器或内存位置中的符号位进行取值。如果xmm2/m128中对应字节的符号位为0，则结果字节取正值；如果xmm2/m128中对应字节的符号位为1，则结果字节取负值。

PSIGNB srcdest, src // MMX 64-bit Operands
    VL=64
    KL := VL/8
    for i in 0...KL-1:
     srcdest.byte[i] := byte_sign(src.byte[i], srcdest.byte[i])


PSIGNB srcdest, src // SSE 128-bit Operands
    VL=128
    KL := VL/8
    FOR i in 0...KL-1:
     srcdest.byte[i] := byte_sign(src.byte[i], srcdest.byte[i])

PSIGNW

PSIGNW mm1, mm2/m64
           Negate/zero/preserve packed word integers in mm1 depending

      on the corresponding sign in mm2/m128.

将mm1寄存器中的每个字（16位）根据mm2/m64寄存器或内存位置中的符号位进行取值。如果mm2/m64中对应字的符号位为0，则结果字取正值；如果mm2/m64中对应字的符号位为1，则结果字取负值。


PSIGNW xmm1, xmm2/m128
            Negate/zero/preserve packed word integers in xmm1 depending

        on the corresponding sign in xmm2/m128.

将xmm1寄存器中的每个字（16位）根据xmm2/m128寄存器或内存位置中的符号位进行取值。如果xmm2/m128中对应字的符号位为0，则结果字取正值；如果xmm2/m128中对应字的符号位为1，则结果字取负值。

PSIGNW srcdest, src // MMX 64-bit Operands
    VL=64
    KL := VL/16
    FOR i in 0...KL-1:
     srcdest.word[i] := word_sign(src.word[i], srcdest.word[i])

PSIGNW srcdest, src // SSE 128-bit Operands
    VL=128
    KL := VL/16
    FOR i in 0...KL-1:
     srcdest.word[i] := word_sign(src.word[i], srcdest.word[i])

PSIGND

PSIGND mm1, mm2/m64
              Negate/zero/preserve packed doubleword integers in mm1 depending

        on the corresponding sign in mm2/m128.

将mm1寄存器中的每个双字（32位）根据mm2/m64寄存器或内存位置中的符号位进行取值。如果mm2/m64中对应双字的符号位为0，则结果双字取正值；如果mm2/m64中对应双字的符号位为1，则结果双字取负值。

PSIGND xmm1, xmm2/m128 
          Negate/zero/preserve packed doubleword integers in xmm1 depending

       on the corresponding sign in xmm2/m128.

于将xmm1寄存器中的每个双字（32位）根据xmm2/m128寄存器或内存位置中的符号位进行取值。如果xmm2/m128中对应双字的符号位为0，则结果双字取正值；如果xmm2/m128中对应双字的符号位为1，则结果双字取负值。

PSIGND srcdest, src // MMX 64-bit Operands
    VL=64
    KL := VL/32
    FOR i in 0...KL-1:
     srcdest.dword[i] := dword_sign(src.dword[i], srcdest.dword[i])

PSIGND srcdest, src // SSE 128-bit Operands
    VL=128
    KL := VL/32
    FOR i in 0...KL-1:
     srcdest.dword[i] := dword_sign(src.dword[i], srcdest.dword[i])

Packed Align Right:
PALIGNR

PALIGNR mm1, mm2/m64, imm8
         Concatenate destination and source operands,

        extract byte-aligned result shifted to the right by constant value in imm8 into mm1.

        将mm1寄存器和mm2/m64寄存器或内存位置中的数据进行对齐和移位操作，

        imm8参数指定了移位的位数。

PALIGNR xmm1, xmm2/m128, imm8

        Concatenate destination and source operands,

        extract byte-aligned result shifted to the right by constant value in imm8 into xmm1.

        将xmm1寄存器和xmm2/m128寄存器或内存位置中的数据进行对齐和移位操作，

        imm8参数指定了移位的位数

PALIGNR (With 64-bit Operands)
        temp1[127:0] = CONCATENATE(DEST,SRC)>>(imm8*8) 
        DEST[63:0] = temp1[63:0] 
PALIGNR (With 128-bit Operands)
        temp1[255:0] := ((DEST[127:0] << 128) OR SRC[127:0])>>(imm8*8);
        DEST[127:0] := temp1[127:0]
        DEST[MAXVL-1:128] (Unmodified)

intel SIMD指令参考手册
02-06
intel SIMD指令参考手册
德卡SSSE32.dll
01-19
社保卡二次开发库，主要用于社会保障卡系统的软件的二次开发
SSSE3指令集
weixin_34411563的博客
03-29 782
这里简要描述几个重要的算数运算指令。 1. 水平相加指令 SSSE3指令集增加的主要是针对整数进行水平方向上相加的指令，与SSE3的浮点指令类似。 　　phaddd 　　寄存器水平方向上按照无符号32位整数进行加法 　　phaddw 　寄存器水平方向上按照无符号16位整数进行加法 　　phaddsw 　　寄存器水平方向上按照16位整数进行饱和加法 ...
SSSE3指令集----水平加法指令饱和字节乘加指令以及字节重排指令
CeleryChen 致力于语音图像视频算法在各种硬件体系结构下的最优化实现
04-23 2998
这里简要描述几个重要的算数运算指令。 1.  水平相加指令       SSSE3指令集增加的主要是针对整数进行水平方向上相加的指令，与SSE3的浮点指令类似。 　　phaddd 　　寄存器水平方向上按照无符号32位整数进行加法   　　phaddw    　寄存器水平方向上按照无符号16位整数进行加法   　　phaddsw 　　寄存器水平方向上按照16位整数进行饱和加法
SSE3指令集系列
weixin_33871366的博客
03-29 570
1. 数据加载存储指令 LDDQU xmm, m128 从非对齐的内存地址中加载128位数到XMM寄存器，此条指令比SSE2的非对齐加载指令 MOVDQU 要快。 MOVDDUPxmm,xmm/m64 加载64bit数据到XMM寄存器的低64位，同时复制到其高64位。 MOVSHDUP xmm， xmm/m128 只需复制第二与第...
SSE3和SSSE3 Intrinsics各函数介绍
架构设计
03-16 377
SIMD相关头文件包括： //#include &lt;ivec.h&gt;//MMX //#include &lt;fvec.h&gt;//SSE(also include ivec.h) //#include &lt;dvec.h&gt;//SSE2(also include fvec.h) #include &lt;mmintrin.h&gt; //MMX #include &lt...
Glibc 删除关于 SSSE3 优化的代码路径
u014389734的博客
04-23 799
最新的 GNU C Library (Glibc) 开发代码已经开始丢弃各种 SSSE3 优化代码路径。其中包括删除 mem{move| cpy }-ssse3-back、str{p}{n}cpy-ssse3、str{n}cat-ssse3、str{n}{case}cmp-ssse3 和 {w }memcmp-ssse3 代码路径。 根据介绍，Supplemental Streaming SIMD Extensions 3 (SSSE3) 可以追溯到十多年前的 Intel Xeon 5100 / C
intel_intel指令集_intel_
10-03
5. **多媒体和向量指令**：包括MMX、SSE（Streaming SIMD Extensions）、SSE2、SSE3、SSSE3、SSE4等，这些扩展指令集增强了处理器处理多媒体数据和向量操作的能力，提高了性能。 6. **多线程和超线程指令**：如HLT...
Intel x86-64 汇编指令集详解
5. **扩展指令集**：新增了一些优化指令，如SSE3、SSSE3、SSE4、AVX、AVX2等，用于提升浮点运算、多媒体处理和向量计算性能。 6. **寄存器重命名**：通过寄存器重命名技术，处理器可以并行处理更多的指令，减少数据...
汇编优化的3D数学库：效率超越D3D十倍
SSE（Streaming SIMD Extensions）是英特尔公司开发的一系列指令集扩展，用于增强多媒体和3D图形处理的性能，特别是通过支持单指令多数据（SIMD）操作，允许在单一指令中处理多个数据。SSE指令集最初于1999年随奔腾...
全面详尽x86汇编指令集完整列表
SSSE3（Supplemental Streaming SIMD Extensions 3）是对SSE3的增强，提供了额外的SIMD指令来处理一系列数据，使编程者能更有效地进行数据处理和算法实现。 ### SSE4指令集 SSE4指令集进一步增强了处理器的多媒体...
SSSE32动态库说明.pdf
01-08
SSSE32动态库说明.pdf,详细介绍了SSSE32的调方接口及入参和出参。
C++中使用SIMD的几种方法
热门推荐
06-02 3万+
图7列出了使用SIMD技术的多种方法，我们先按从上至下的顺序简要介绍每一种，然后重点介绍汇编语言方法。图7 使用SIMD技术的多种方法第一种方法是使用著名的IPP库，IPP的全称是Intel Integrated Performance Primitives， 是英特尔公司开发的一套跨平台软件函数库，提供了非常广泛的功能，包括各种常用的图形图像、音视频处理函数。因为其中的很多函数都已经使用SIMD...
遇到SSE相关指令含义整理
liutianheng654的博客
10-15 3495
工作需要逆向微信部分代码，遇到了这个指令集，资料很少，整理如下： xmm0~xmm7 128位 mm0~mm7     64位 byte     一个字节、8bit dword   双字，4个字节，32bit qword   四字，8个字节，64bit 指令含义参照如下英文链接： https://www.felixcloutier.com/x86/index.html movdqu...
SSE与AVX指令基础介绍与使用
ThousandPine的博客
07-14 3028
SSE/AVX指令属于Intrinsics函数，由编译器在编译时直接在调用处插入代码，避免了函数调用的额外开销。但又与inline函数不同，Intrinsics函数的代码由编译器提供，能够更高效地使用机器指令进行优化调整。在开始之前可以先在CPU-Z或者查看自己CPU的指令集支持情况。关于SSE和AVX内部函数的相关信息也都可以在查看。
计算机系统: 高性能处理器指令集SSE3详解
m0_72410588的博客
08-30 1362
SSE3（Streaming SIMD Extensions 3）指令集是Intel公司在2004年推出的一种SIMD指令集，主要用于加速浮点数运算和多媒体应用程序。与之前的SSE2指令集相比，SSE3指令集主要增加了一些新的指令，可以更好地支持多线程、多核心处理器。SSE3指令集还可以实现更加高效的算法和数据操作，以及更快的数据传输和数据存储速度，从而提高计算机系统的整体运行速度。
avx sse系列介绍
SteveForever的博客
08-11 2420
SSE（Streaming SIMD Extensions）家族是由英特尔引入的一组指令集扩展，用于提高多媒体、科学计算和其他领域的处理性能。SSE家族随着时间的发展，增加了多个版本和子集。总的来说，SSE家族通过逐步增加新指令和优化现有指令，显著提高了处理器在多媒体、科学计算、加密等领域的性能。这些改进使得SSE成为了现代处理器中不可或缺的一部分。AVX（Advanced Vector Extensions）家族是英特尔和AMD处理器中用于提高浮点和整数运算性能的一组指令集扩展。
Native开发工具之CPU 和架构（三）
AndroidAlvin的博客
11-25 684
阿里P7移动互联网架构师进阶视频（每日更新中）免费学习请点击：https://space.bilibili.com/474380680 一、简介 使用原生代码时，硬件很重要。NDK 提供各种 ABI 供您选择，可让您确保针对正确的架构和 CPU 进行编译。 本部分介绍了在编译时如何面向特定的架构和 CPU，如何使用 ARM NEON 扩展指令集，以及在运行时如何使用 cpufeat...
SSE和AVX指令基本使用
最新发布
哦豁灬
08-26 2841
SSE/AVX 指令属于 Intrinsics 函数，由编译器在编译时直接在调用处插入代码，避免了函数调用的额外开销。但是与 inline 函数不同，Intrinsics 函数的代码由编译器提供，能够更高效地使用机器指令进行优化调整。一般的函数是在库中，Intrinsic Function 内嵌在编译器中（built in to the compiler）。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值