Asembler x86/Instrukcje/SSSE3

PSIGBN, PSIGNW, PSIGND działają — odpowiednio — na wektorach bajtów, słów bądź podwójnych słów ze znakiem, zmieniając znaki tych elementów w argumencie docelowym, dla których odpowiadające im elementy argumentu źródłowego są ujemne.

Np. rozkaz PSIGNW xmm1, xmm2 wykonuje:

 for i:=0 to 7 do
    if xmm2[i] < 0 then
       xmm1[i] := - xmm1[i];

albo zapisując z wykorzystaniem funkcji signum:

 for i:=0 to 7 do
    xmm[i] := xmm1[i] * SIGN(xmm2[i]);

PABSB, PABSW, PABSD działają - odpowiednio - na wektorach bajtów, słów bądź podwójnych słów ze znakiem, obliczając wartość bezwzględną każdego z elementów wektora źródłowego.

Np. rozkaz PABSB xmm1, xmm2 wykonuje:

 for i:=0 to 15 do
    xmm1[i] := ABS(xmm2[i]);

PHSUBW i PHSUBD działają podobnie do PHADDx, z tą różnicą, że odejmują sąsiednie elementy; od elementu o indeksie parzystym odejmowany jest element o indeksie parzystym. Rozkaz PHSUBSW wykonuje to samo działanie co PHSUBW, z tym, że wyniki odejmowania są nasycane.

Np. rozkazowi PHSUBW xmm1, xmm2 odpowiada:

  for i:=0 to 3 do
   begin
     temp[i]   := xmm1[2*i] - xmm1[2*i+1];
     temp[i+4] := xmm2[2*i] - xmm2[2*i+1];
   end;

PHADDW, PHADDD działają − odpowiednio − na wektorach słów bądź podwójnych słów ze znakiem, wykonując dodawanie sąsiednich elementów. PHADDSW wykonuje to samo działanie co PHADDW, z tym, że wyniki dodawania są nasycane.

Np. rozkazowi PHADDW xmm1, xmm2 odpowiada:

 for i:=0 to 3 do
   begin
     temp[i]   := xmm1[2*i] + xmm1[2*i+1];
     temp[i+4] := xmm2[2*i] + xmm2[2*i+1];
   end;

PMULHRSW mnoży wektory słów ze znakiem; wyniki mnożenia są zaokrąglane zgodnie z algorytmem:

• wynikiem mnożenia liczb 16-bitowych jest liczba 32-bitowa,
• z wyniku brane jest wartość pośrednia - 18 najstarszych bitów (tj. bity 14..31),
• która następnie zwiększana jest o 1,
• ostatecznie zapisuje się 16 najstarszych bitów z 18-bitowego wyniku pośredniego.

Np. rozkazowi PMULHRSW xmm1, xmm2 odpowiada:

 for i:=0 to 7 do
   begin
     temp := xmm1[i] * xmm2[i]; { mnożenie 16-bitowych liczb }
     temp := temp SAR 14;       { 18 najstarszych bitów wyniku }
     temp := temp + 1;
     xmm1[i] := temp SAR 2;     { 16 najstarszych bitów temp }
   end;

PMADDUBSW wykonuje mnożenie dwóch wektorów bajtów, traktując bajty z wektora docelowego jako liczby bez znaku, natomiast ze źródłowego - ze znakiem; wynikiem pośrednim jest wektor 16-bitowych liczb ze znakiem. Następnie sąsiednie elementy tego wektora są do siebie dodawane (jak w rozkazie PHADDSW, a wyniki nasycane - w przykładzie ostatniemu działaniu odpowiada psuedofunkcja Sat.

Np. rozkazowi PMADDUBSW xmm1, xmm2 odpowiada:

 { wektor pośredni }
 for i:=0 to 15 do
   temp[i] := xmm1[i] * xmm2[i];
 
 { sumowanie }
 for i:=0 to 8 do
    xmm1[i] := Sat(temp[2*i] + temp[2*i+1]);

PSHUFB rozmieszcza elementy w wektorze bajtów zgodnie ze wzorcem zapisanym w wektorze źródłowym.

Każdy bajt wzorca określa, jaka wartość zostanie zapisana na odpowiadającej mu pozycji w wynikowym wektorze:

• jeśli najstarszy bit jest ustawiony, to zapisywany jest bajt o wartości zero;
• w przeciwnym razie cztery lub trzy najmłodsze bity (zależnie, czy rozkaz działa na rejestrach XMM czy MMX) określają indeks bajta w wektorze docelowym, który zostanie przepisany do wyniku.

Rozkaz PSHUFB xmm1, xmm2 (128-bitowe argumenty) wykonuje:

 for i:=0 to 15 do
  begin
   if xmm2[i] AND 10000000b <> 0 then { ustawiony najstarszy bit }
     temp[i] := 0;
   else do;
     index = xmm2[i] AND 00001111b;   { albo indeks }
     temp[i] := xmm1[index];
   end;
  end;
 xmm1 := temp;

Np. dla danych

        0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm2 = |0 |1 |2 |1 |3 |4 |5 |1 |6 |7 |0 |1 |2 |1 |7 |8 | (bajty jako liczby)
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm1 = |W |i |k |p |e |d |a |- |. |  |  |  |  |  |  |  | (bajty jako znaki ASCII)
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       

wynikiem działania PSHUFB xmm1, xmm2 będzie:

        0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm1 = |W |i |k |i |p |e |d |i |a |- |W |i |k |i |- |. |  
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

PALIGNR łączy dwa 16-bajtowe wektory w jeden, 32-bajtowy, po czy wybiera z niego pewien zakres 16 bajtów i zapisuje w wektorze docelowym. Początek zakresu jest wskazywany przez trzeci argument rozkazu, 8-bitową stałą natychmiastową imm8.

Rozkazowi PALIGNR xmm1, xmm2, imm8 (128-bitowe argumenty, tj. 16-elementowe wektory) odpowiada

 { połączenie wektorów }
 { temp - wektor 32-elementowy }
 for i := 0 to 15 do begin
   temp[i]    := xmm1[i];
   temp[i+16] := xmm2[i];
 end;

 { wybranie fragmentu }
 for i := 0 to 15 do
   xmm1[i] := temp[i + imm8];

Np.

        0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm1 = |W |i |k |i |p |e |d |i |a |, |  |W |o |l |n |a |  
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       
        16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm2 = |  |E |n |c |y |k |l |o |p |e |d |i |a |  |  |  |
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

Wynik działania PALIGNR xmm1, xmm2, 11:

        0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
xmm1 = |W |o |l |n |a |  |E |n |c |y |k |l |o |p |e |d |  
       +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+