Brainscape's Knowledge GenomeTM

Browse over 1 million classes created by top students, professors, publishers, and experts.


See full index

POPRAWA > nisko > Flashcards

nisko Flashcards

1
Q

 FINCSTP
 FDECSTP
 FFREE
 FINIT
 FNINIT
 FCLEX
 FNCLEX
 FSTCW
 FNSTCW
 FLDCW
 FSTENV
 FNSTENV
 FLDENV
 FSAVE
 FNSAVE
 FRSTOR
 FSTSW
 FNSTSW
 WAIT/FWAIT
 FNOP

A

 FINCSTP zwiększenie rejestru wskaźnika stosu koprocesora
 FDECSTP zmniejszenie rejestru wskaźnika stosu koprocesora
 FFREE zwolnienie rejestru zmiennoprzecinkowego
 FINIT inicjalizacja koprocesora po sprawdzeniu zgłoszenia błędu numerycznego
 FNINIT inicjalizacja koprocesora bez sprawdzenia zgłoszenia błędu numerycznego
 FCLEX zerowanie flag błędów numerycznych po sprawdzeniu zgłoszenia błędu numerycznego
 FNCLEX zerowanie flag błędów numerycznych bez sprawdzenia zgłoszenia błędu numerycznego
 FSTCW zapamiętanie rejestru sterowania po sprawdzeniu zgłoszenia błędu numerycznego
 FNSTCW zapamiętanie rejestru sterowania bez sprawdzenia zgłoszenia błędu numerycznego
 FLDCW wczytanie rejestru sterowania
 FSTENV zapamiętanie środowiska koprocesora po sprawdzeniu zgłoszenia błędu numerycznego
 FNSTENV zapamiętanie środowiska koprocesora bez sprawdzenia zgł. błędu numerycznego
 FLDENV wczytanie środowiska koprocesora
 FSAVE zapamiętanie zawartości koprocesora po sprawdzeniu zgłoszenia błędu numerycznego
 FNSAVE zapamiętanie zawartości koprocesora bez sprawdzenia zgłoszenia błędu numerycznego
 FRSTOR wczytanie zawartości koprocesora
 FSTSW zapamiętanie rejestru stanu po sprawdzeniu zgłoszenia błędu numerycznego
 FNSTSW zapamiętanie rejestru stanu bez sprawdzenia zgłoszenia błędu numerycznego
 WAIT/FWAIT czekanie na koprocesor
 FNOP nic nie robi

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

 FXSAVE
 FXRSTOR
 EMMS
 LDMXCSR
 STMXCSR

A

 FXSAVE zapisanie stanu x87 FPU i rejestrów SIMD
 FXRSTOR wczytanie stanu x87 FPU i rejestrów SIMD
 EMMS zwalnia wszystkie rejestry koprocesora
 LDMXCSR wczytanie rejestru MXCSR
 STMXCSR zapisanie rejestru MXCSR

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

 PAVGB
 PAVGW
 PEXTRW
 PINSRW
 PMAXUB
 PMAXSW
 PMINUB
 PMINSW
 PMOVMSKB
 PMULHUW
 PSADBW
 PSHUFW

A

 PAVGB oblicza średnią z elementów wektorów bajtów bez znaku
 PAVGW oblicza średnią z elementów wektorów słów bez znaku
 PEXTRW wydobycie słowa
 PINSRW wstawienie słowa
 PMAXUB oblicza maksimum z elementów wektorów bajtów bez znaku
 PMAXSW oblicza maksimum z elementów wektorów słów ze znakiem
 PMINUB oblicza minimum z elementów wektorów bajtów bez znaku
 PMINSW oblicza minimum z elementów wektorów słów ze znakiem
 PMOVMSKB przesłanie maski bajtów
 PMULHUW mnożenie wektorów słów bez znaku i zapamiętanie starszych słów
wyniku
 PSADBW oblicza sumę wartości bezwzględnych różnic
 PSHUFW tasuje słowa w rejestrze MMX

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

XGETBV

A

Czyta do edx:eax zawartość rozszerzonego rejestru
kontrolnego o indeksie ecx.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

FCOM
FCOMI
FICOM

A

FCOM - przecinki flagi c0,c1 itd
FCOMI - przecinki + eflags
FICOM - całkowite

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

LOCK

A

LOCK:
-niepodzielne instrukcje
-bit test: bts, btr, btc
-zamiana: xchg, cmpxchg, cmpxchg8b, cmpxchg16b
-dodawania: add, adc, xadd
-odejmowanie: sub, sbb
-inkrementacja: inc, dec
-logiczne: and, or, xor, not, neg

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

VMOV[D/Q]

A

Instrukcja przesłania
vmovd xmm1, r/m32 xmm1 ← r/m32
vmovq xmm1, r/m64 xmm1 ← r/m64
vmovq xmm1, xmm2/m64 xmm1 ← xmm2/m64
vmovd r/m32, xmm1 r/m32 ← xmm1
vmovq r/m64, xmm1 r/m64 ← xmm1
vmovq xmm1/m64, xmm2 xmm1/m64 ← xmm2
VMOVD / VMOVQ przesyła podwójne lub poczwórne słowo z rejestru ogólnego przeznaczenia/pami ęci
do rejestru xmm lub odwrotnie. Używany jest jeden najmłodszy element rejestru xmm, starsze elementy
są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

VMOVDQ[A/U]
do ilu wyrownanie?

A

vmovdq[a/u] xmm1, xmm2/m128
vmovdq[a/u] ymm1, ymm2/m256
vmovdq[a/u] xmm2/m128, xmm1
vmovdq[a/u] ymm2/m256, ymm1
Przesyła całą zawartość (128 lub 256 bitów) źródła do celu, jeśli celem lub źródłem jest pamięć,
wówczas w wersji (A) dane w pamięci muszą być wyrównane (ang. aligne) do granicy 16 (m128) lub 32
(m256) bajtów, w przeciwnym wypadku zgłaszany jest wyjątek ochrony pamięci. Aby przesłać dane do/z
niewyrównanych lokalizacji pamięci należy w instrukcji zamiast (A) użyć (U) (ang. unaligne) .
cel (r) ← źródło (r/m) cel (r/m) ← źródło

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

VMOVNTDQ[A]

A

vmovntdqa xmm1, m128 cel (r) ← źródło (m)
vmovntdqa ymm1, m256
vmovntdq m128, xmm1 cel (m) ← źródło (r)
vmovntdq m256, ymm1
Przesyła całą zawartość z/do pamięci m128/m256 do/z rejestru xmm1/ymm1.
Dla instrukcji w wersji (A) pamięć musi być wyrównana (ang. aligne) do granicy 16 (m128) lub 32 (256)
bajtów, w przeciwnym wypadku zgłaszany jest wyjątek ochrony pamięci, alternatywnie można zastosować
instrukcję bez litery A. NT oznacza (non-temporal hint) przesłanie z pominięciem pamięci podręcznej
(cache).

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

VLDDQU

A

vlddqu xmm1, m128
vlddqu ymm1, m256
Ładuje 256/128 bitowe dane całkowite z niewyrównanej pamięci do rejestru celu

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

VPMOVMSKB

A

vpmovmaskb reg, xmm1 rejestr ← xmm1
vpmovmaskb reg, ymm1 rejestr ← ymm1 (AVX2)
Przesyła najstarsze bity (bity znaku) każdego bajtu rejestru xmm1/ymm1 po kolei do rejestru r32/r64,
dla xmm przenosi 16 bitów do r32, dla ymm przenosi 32 bity do r64, pozostałe starsze bity są zerowane.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

VPMOV[S/Z]XB[W/D/Q], VPMOV[S/Z]XW[D/Q]
VPMOV[S/Z]XDQ

A

vpmov[s/z]xbw xmm1, xmm2/m64
vpmov[s/z]xbd xmm1, xmm2/m32
vpmov[s/z]xbq xmm1, xmm2/m16
40
VPMOV[S/Z]XB[W/D/Q], VPMOV[S/Z]XW[D/Q]
VPMOV[S/Z]XDQ
vpmov[s/z]xwd xmm1, xmm2/m64
vpmov[s/z]xwq xmm1, xmm2/m32
vpmov[s/z]xdq xmm1, xmm2/m64
Instrukcja zamienia (konwertuje) ze znakiem / bez znaku:
bajty na słowa/podwójne słowa/poczwórne słowa, słowa na podwójne słowa/poczwórne słowa,
podwójne słowa na poczwórne słowa przepisując odpowiednio wartości z młodszej części rejestru
xmm2/(m64||m32||m16) do rejestru celu xmm1.
W AVX2 młodsza część rejestru ymm

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

VMASKMOVDQU

A

vmaskmovdqu xmm1, xmm2
Celem jest obszar 16 bajtów pamięci adresowany przez DS: DI / EDI / RDI.
Bajty ze źródła xmm1 są przesyłane do celu pod warunkiem, że siódme bity (bity znaku) odpowiadających
im bajtów z xmm2 są jedynkami.
xmm2 = maska
if xmm2[i][7] = 1 then m128[i] = xmm1[i]
i – jest numerem bajtu

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

VPMASKMOV[D/Q]

A

vpmaskmov[d/q] xmm1, xmm2, m128
vpmaskmov[d/q] ymm1, ymm2, m256
vpmaskmov[d/q] m128, xmm1, xmm2
vpmaskmov[d/q] m256, ymm1, ymm2
Przesyła podwójne/poczwórne słowa z pamięci m128/m256 lub xmm2/ymm2 do rejestru celu xmm2/ymm2
lub pamięci m128/m256 , pod warunkiem, że bit znaku odpowiadających wartości z rejestru maski (drugi
operand) xmm2/ymm2 lub xmm1/ymm1 jest ustawiony na jeden, w przeciwnym wypadku zapisuje zero.
if źródło1[i][31/63] == 1 then cel[i] ← źródło2[i] else cel[i] ← 0
Bity od 128/256 do MSB są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

VPACK[S/U]SWB

A

vpack[s/u]swb xmm1, xmm2, xmm3/m128
vpack[s/u]swb ymm1, ymm2, ymm3/m256 (AVX2)
Konwertuje słowa ze znakiem na bajty ze znakiem (S) / bez znaku(U), z rejestru xmm2 / ymm2 wpisuje
do młodszych części rejestru xmm1, a z xmm3/m128 / ymm3/ m256 wpisuje do starszych części rejestru
xmm1/ ymm1. Starsza część rejestru ymm1 jest wypełniana danymi ze starszych części rejestrów hi ymm2 i
hi ymm3/m256. Wynik jest zapisywany ze znakiem(S) / bez znaku(U) oraz z nasyceniem.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

VPACK[S/U]SDW

A

vpack[s/u]sdw xmm1, xmm2, xmm3/m128
vpack[s/u]sdw ymm1, ymm2, ymm3/m256 (AVX2)
Konwertuje podwójne słowa ze znakiem na słowa ze znakiem(S)/bez znaku(U), z rejestru xmm2/ lo
ymm2 wpisuje do młodszych części rejestru xmm1/ lo ymm1, z xmm3/m128 / lo ymm3/ lo m256 wpisuje
do starszych części rejestru celu xmm1/lo ymm1. Starsza część rejestru ymm1, jest wypełniana danymi ze
starszych części rejestrów hi ymm2 oraz hi ymm3/m256. Wynik jest zapisywany ze znakiem(S) / bez
znaku(U) oraz z nasyceniem

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

VPUNPCKLBW

A

vpunpcklbw xmm1, xmm2, xmm3/m128
vpunpcklbw ymm1, ymm2, ymm3/m256 (AVX2)
Młodsze bajty ze 128 bitowych części rejestru ymm2 (xmm2) oraz ymm3 (xmm3)/m256(m128) zapisuje z
przeplotem do rejestru celu ymm1/xmm1

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

VPUNPCKHBW

A

vpunpckhbw xmm1, xmm2, xmm3/m128
vpunpckhbw ymm1, ymm2, ymm3/m256 (AVX2)
Starsze bajty ze 128 bitowych części rejestru ymm2 (xmm2) oraz ymm3 (xmm3)/m256(m128) zapisuje z
przeplotem do rejestru celu ymm1/xmm1.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

VEXTRACTI128

A

vextracti128 xmm1/m128, ymm2, imm8 (AVX2)
Przepisuje 128 bitów z rejestru ymm2 do rejestru xmm1 lub m128. Jeśli zerowy bitu bajtu sterującego
imm8[0] = o przepisuje młodszą część, a jeśli imm8[0] = 1 przepisuje starszą część rejestru ymm2.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

VINSERTI128

A

vinserti128 ymm1, ymm2, xmm3/m128, imm8 (AVX)
Przepisuje cały rejestr ymm2 do ymm1 następnie przepisuje rejestr xmm3 lub m128 również do rejestru
celu ymm1 zależnie od ustawienia bitu bajtu sterującego: imm8[0] = 0 przepisuje xmm3/m128 na młodszą
część, gdy imm8[0] = 1 na starszą część celu ymm1

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

VPSHUFB

A

vpshuf b xmm1, xmm2, xmm3/m128
vpshuf b ymm1, ymm2, ymm3/m256 (AVX2)
Tasuje bajty z xmm2/ymm2, w zależności od bitu znaku kolejnych bajtów rejestru xmm3/m128 /
ymm3/m256. Jeśli bit znaku jest ustawiony odpowiedni bajt rejestru celu xmm1/ymm1 jest zerowany, jeśli
bit znaku xmm3/ymm3 / m128/m256 nie jest ustawiony wówczas z takiego bajtu jest tworzony 4 bitowy
indeks wskazujący numer bajtu ze 128-bitowej części, który ma być przepisany z xmm2/ymm2 do
właściwego xmm1/ymm1.
i = numer bajtu
if xmm3/m128[i][7] == 1 then xmm1[i] = 0
else { index[3..0] = xmm3/m128[i][3..0]
xmm1[i] = xmm2[index]
}

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

VPSHUFD

A

vpshufd xmm1, xmm2/m128, imm8
vpshufd ymm1, ymm2/m256, imm8 (AVX2)
Tasuje podwójne słowa z rejestru xmm2/m128/ymm2/m256 według dwubitowych wartości bajtu sterującego imm8 (argument
kolejności), wynik zapisuje w xmm1/ymm1, tasowanie odbywa się w blokach 128 bitowych

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

VPSHUFLW

A

vpshuf lw xmm1, xmm2/m128, imm8 (AVX)
vpshuf lw ymm1, ymm2/m256, imm8 (AVX2)
Tasuje wektory młodszych słów z rejestru xmm2/ymm2 według dwubitowych wartości bajtu sterującego
imm8 (argument kolejności), wynik zapisuje odpowiednio w xmm1/ymm1

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

VPERMD

A

vpermd ymm1, ymm2, ymm3/m256 (AVX2)
Wykonuje permutacje wektorów podwójnych słów z rejestru ymm3/m256 według porządku podanego w ymm2, najmłodsze
3 bity odpowiedniego podwójnego słowa rejestru ymm2 wyznaczają, z którego miejsca w ymm3/m256 zostanie skopiowane
podwójne słowo do miejsca położenia „adresu” (ymm2). Wynik jest zapisywany w ymm1.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
Q

VPERMQ

A

vpermq ymm1, ymm2/m256, imm8 (AVX2)
Wykonuje permutacje wektorów poczwórnych słów z rejestru ymm2/m256 według porządku
określonego w imm8, kolejne dwubitowe pola imm8 określają, spod którego indeksu „adresu” zostaną
skopiowane poczwórne słowa z ymm2/m56. Wynik jest zapisywany do ymm1.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
26
Q

VPERM2I128

A

vperm2i128 ymm1, ymm2, ymm3/m256, imm8 (AVX2)
Wykonuje permutacje dwóch wektorów 128 bitowych z rejestrów ymm2 oraz ymm3/m256, bajt sterujący
imm8 odpowiada za sposób przepisania, pola imm8[5:4] i imm8[1:0] są indeksami wskazującymi skąd
należy pobrać starszą i młodszą część rejestru celu, bity imm8[7 ] = 1 i imm8[3] = 1 powodują
wyzerowanie starszej i młodszej części.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
27
Q

VPBLENDVB

A

vpblendvb xmm1, xmm2, xmm3/m128, xmm4 (AVX)
vpblendvb ymm1, ymm2, ymm3/m256, ymm4 (AVX2)
Miesza wektory bajtów z rejestru xmm2/ymm2 oraz xmm3/ymm3 lub m128/m256 według bitu znaku
każdego bajtu w xmm4/ymm4, wynik zapisuje w xmm1/ymm1.
i <o, 15> lub <o, 31> - indeks bajtu
if źródło3 [i][7] = 1 => cel[i] = źródło2[i]
else cel[i] = źródło1[i]
if xmm4 [i][7] = 1 => xmm1[i] = xmm3/m128[i]
else xmm1l[i] = xmm2[i]
if ymm4[i][7] = 1 => ymm1[i] = ymm3/m256[i]
else ymm1[i] = ymm2[i]
78
Bity od 128/256 do MSB są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
28
Q

VPBLENDW

A

vpblendw xmm1, xmm2, xmm3/m128, imm8 (AVX)
vpblendw ymm1, ymm2, ymm3/m256, imm8 (AVX2)
W oparciu o bajt kontrolny miesza wektory słów; wybiera elementy wektora z rejestru xmm3/ymm3 lub
m128/m256 dla imm8[i] = 1, albo elementy wektora xmm2/ymm2 dla imm8[i] = 0. Dla indeksu 8-15 należy
wziąć imm8[i-8]. Wynik zapisuje w xmm1/ymm1.
i <o, 7> lub <o, 15> - indeks słowa
if imm8[i modulo 8] = 1 then cel[i] = źródło2[i]
else cel[i] = źródło1[i]
if imm8[i]= 1 then xmm1[i] = xmm3/m128[i]
else xmm1l[i] = xmm2[i]
if imm8[i modulo 8] = 1 then ymm1[i] = ymm3/m256[i]
else ymm1[i] = ymm2[i]
80
Bity od 128/256 do MSB są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
29
Q

VPBLENDD

A

vpblendd ymm1, ymm2, ymm3/m256, imm8 (AVX2)
Miesza wektory podwójnych słów z rejestru ymm2 oraz ymm3 lub m256, w oparciu o specyfikację z bajtu
kontrolnego imm8, wynik zapisuje w ymm1.
i <o, 7> - indeks podwójnego słowa
if imm8[i] = 1 then cel[i] = źródło2[i]
else cel[i] = źródło1[i]
if imm8[i] = 1 then ymm1[i] = ymm3/m256[i]
else ymm1[i] = ymm2[i]
82

Bity od 128/256 do MSB są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
30
Q

VPGATHER[D/Q][D/Q]

A

Instrukcja kompletuje wektor xmm1/ymm1 używając
adresów w postaci podwójnych/poczwórnych słów
zdefiniowanych w vm32[x/y]/vm64[x/ y] używając jako
indeksów podwójnych/poczwórnych słów zapisanych w
xmm2/ymm2 do wskazanej lokalizacji pamięci skąd
pobierane są wartości podwójnego/poczwórnego słowa.
Pobierane z pamięci wartości są zapisywane do rejestru celu
xmm1/ymm1 tylko wówczas gdy najstarsze bity
odpowiednich elementów wektora maski xmm3/ymm3 są
równe 1.

Bity od 128/256 do MSB są zerowane.

vpgatherdd xmm1, vm32x, xmm3
vpgatherqd xmm1, vm64x, xmm3
vpgatherdd ymm1, vm32y, ymm3
vpgatherqd ymm1, vm64y, ymm3
vpgatherdq xmm1, vm32x, xmm3
vpgatherqq xmm1, vm64x, xmm3
vpgatherqq ymm1, vm32y, ymm3
vpgatherqq ymm1, vm64y, ymm3

W opisie instrukcji vm32x wskazuje wektor czterech 32-bitowych
wartości adresów dla konkretnego xmm, vm32y wektor
ośmiu 32- bitowych wartości indeksów dla konkretnego ymm.
Notacja vm64x i vm64y wskazuje analogicznie
na maksymalnie dwa lub cztery adresy

Działanie instrukcji gather
Pobiera z pamięci o wskazanej lokalizacji określonej tu jako adres_fizyczny wartości
podwójnych/poczwórnych słów i zapisuje je do rejestru celu ymm1/xmm1 tylko wówczas gdy bit znaku
odpowiadającego elementu maski ymm3/xmm3 jest równy jeden, jeśli bit znaku jest równy zero w rejestrze
celu zostaje wartość poprzednia. Po wykonaniu operacji pobierania z pamięci elementy maski są zerowane.
if xmm3[i][63/31] then xmm1[i] ← [adres_fizyczny(xmm2[i])]
if ymm3[i][63/31] then ymm1[i] ← [adres_fizyczny(ymm2[i])]

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
31
Q

Różnica pomiędzy instrukcjami
gather a blend/perm/shuf

A

Instrukcje blend/perm/shuf operują na rejestrach,
zatem najpierw należy załadować dane
z pamięci do rejestru ymm/xmm.
Instrukja gather pobiera dane bezpośrednio z pamięci,
jednak wcześniej trzeba przygotować rejestr indeksów
(rejestr porządku).

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
32
Q

VPADDUS[B/W]

A

vpaddusb xmm1, xmm2, xmm3/m128
vpaddusb ymm1, ymm2, ymm3/m256 (AVX2)
Dodawanie bez znaku wektorów bajtów/słów rejestru xmm2/ymm2 i xmm3/ymm3 lub pamięci
m128/m256, wynik jest zapisywany z nasyceniem w rejestrze xmm1/ymm1.
cel[i] = źródło1[i] + źródło2[i]
xmm1[i] = xmm2[i] + xmm3/m128[i]
ymm1[i] = ymm2[i] + ymm3/m256[i]
101
VPADDUS[B/W]
Bity od 128/256 do MSB są zerowane

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
33
Q

VPHADDW / VPHADDD / VPHADDSW

A

vphaddd xmm1, xmm2,ymm3/m128
vphaddd ymm1, ymm2,ymm3/m256
Horyzontalne dodawanie sąsiednich słów/podwójnych słów i zapisywanie wyniku z przeplotem po 64 bity. Jako najmłodsze
są zapisywane sumy z rejestru xmm2. Ostatnia w/w instrukcja jest dodawaniem słów z nasyceniem.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
34
Q

VPHSUBW / VPHSUBD / VPHSUBSW

A

vphsubd xmm1, xmm2, xmm3/m128
vphsubd ymm1, ymm2, ymm3/m256
Horyzontalne odejmowanie sąsiednich słów/podwójnych słów w ramach 128-bitowych części. Od
młodszego elementu wektora jest odejmowany starszy oraz jako najmłodsze są zapisywane różnice z
rejestru xmm2. Ostatnia instrukcja jest odejmowaniem słów z nasyceniem

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
35
Q

VPSADBW

A

vpsadbw xmm1, xmm2, xmm3/m128
vpsadbw ymm1, ymm2, ymm3/m256 (AVX2)
Od wartości wektorów bajtów rejestru xmm2/ymm2 są odejmowane odpowiednie wartości rejestru
xmm3/ymm3 lub pamięci m128/m256, następnie obliczane są wartości absolutne i ich sumy po 8
elementów, wynik jest zapisywany w rejestrze xmm1/ymm1 dla zestawów 8-elementowych

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
36
Q

VPMULL[W/D]

A

vpmull[w/d] xmm1, xmm2, xmm3/m128
vpmull[w/d] ymm1, ymm2, ymm3/m256 (AVX2)
Mnożenie wektorów słów/podwójnych słów ze znakiem z rejestru xmm2/ymm2 przez odpowiadające im
wartości z xmm3/m128 / ymm3/m256, iloczyny są podwójnymi/poczwór nymi słowami, jednak do
rejestru celu xmm1/ymm1 są zapisywane jedynie młodsze słowa/podwójne słowa iloczynów.
cel[i] = lo (źródło1[i] * źródło2[i])
xmm1[i] = lo ( xmm2[i] * xmm3/m128[i])
ymm1[i] = lo (ymm2[i] * ymm3/m256[i])
114
VPMULL[W/D]
Bity od 128/256 do MSB są zerowane

37
Q

VPMULHW

A

vpmulh[u]w xmm1, xmm2, xmm3/m128
vpmulh[u]w ymm1, ymm2, ymm3/m256 (AVX2)
Mnożenie wektorów słów bez znaku/ze znakiem (U) z rejestru xmm2/ymm2 przez odpowiadające im
wartości z xmm3/m128 / ymm3/m256, iloczyny są podwójnymi słowami, jednak do rejestru celu
xmm1/ymm1 są zapisywane jedynie starsze słowa, iloczynów.
cel[i] = hi (źródło1[i] x źródło2[i])
xmm1[i] = hi (xmm2[i] x xmm3/m128[i])
ymm1[i] = hi (ymm2[i] x ymm3/m256[i])

38
Q

VPMULHRSW

A

vpmulhrsw xmm1, xmm2, xmm3/m128
vpmulhrsw ymm1, ymm2, ymm3/m256 (AVX2)
Mnoży wektory słów ze znakiem ze skalowaniem i zaokrągleniem, wartości z rejestru xmm2/ymm2 przez wartości z
rejestru xmm3/m128 / ymm3/m256, podwójne słowa iloczynów zostają przesunięte w prawo o 14 bitów oraz zostaje dodana
jedynka w celu zaokrąglenia wartości. Bity od 1 do 16 są zapisywane w celu.
cel[i] = ( (źródło1[i] * źródło2[i]&raquo_space; 14) + 1)&raquo_space; 1
xmm1[i] = ((xmm2[i] * xmm3/m128[i]&raquo_space; 14) + 1)&raquo_space; 1
ymm1[i] = ((ymm2[i] * ymm3/m256[i]&raquo_space; 14) + 1)&raquo_space; 1
120
VPMULHRSW
Bity od 128/256 do MSB są zerowane

39
Q

VPMUL[U]DQ

A

vpmul[u]dq xmm1, xmm2, xmm3/m128
vpmul[u]dq ymm1, ymm2, ymm3/m256 (AVX2)
Mnożenie co drugich elementów wektora podwójnych słów ze znakiem/bez znaku (U) xmm2/ymm2 z co
drugimi elementami podwójnych słów ze znakiem xmm3/m128 / ymm3/m256, iloczyny są zapisywane w
xmm1/ymm1 jako wektor poczwórnych słów ze znakiem.
cel[i] = źródło1[2i] * źródło2[2i]
xmm1[i] = xmm2[2i] * xmm3/m128[2i]
ymm1[i] = ymm2[2i] * ymm3/m256[2i]

40
Q

VPCLMULQDQ

A

vpclmulqdq xmm1, xmm2, xmm3/m128, imm8 (AVX)
Mnożenie poczwórnego słowa z xmm2 przez poczwórne słowo z xmm3/m128, iloczyn jest zapisywany w
xmm1.Bity imm8[0] i imm8[4] wybierają młodsze lub starsze (o lub 1) poczwórne słowa z rejestrów xmm2 i
xmm3/m128, które zostaną pomnożone.
if imm8[0] = 0||1 && imm8[4] = 0||1 => cel <- źródło1[ 0||1] * źródło2[ 0||1]
if imm8[0] = 0 && imm8[4] = 0 => xmm1 <- xmm2[63:0] * xmm3/m1228[63:0]
if imm8[0] = 0 && imm8[4] = 1 => xmm1 <- xmm2[63:0] * xmm3/m1228[127:64]
if imm8[0] = 1 && imm8[4] = 0 => xmm1 <- xmm2[127:64] * xmm3/m1228[63:0]
if imm8[0] = 1 && imm8[4] = 1 => xmm1 <- xmm2[127:64] * xmm3/m1228[127:64]

Bity od 128/256 do MSB są zerowane

41
Q

VPMADDWD

A

vpmaddwd xmm1, xmm2, xmm3/m128
vpmaddwd ymm1, ymm2, ymm3/m256 (AVX2)
Mnoży słowa z rejestru xmm2/ymm2 przez słowa z rejestru xmm3/m128 / ymm3/m256, iloczyny są
podwójnymi słowami, następnie kolejne podwójne słowa dodaje horyzontalnie i zapisuje jako podwójne
słowa w rejestrze celu xmm1/ymm1.
cel[i] = źródło1[2i] * źródło2[2i] + źródło1[2i+1] * źródło2[2i+1]
xmm1[i] = xmm2[2i] * xmm3/m128[2i] + xmm2[2i+1] * xmm3/m128[2i+1]
ymm1[i] = ymm2[2i] * ymm3/m128[2i] + ymm2[2i+1] * ymm3/m128[2i+1]

Bity od 128/256 do MSB są zerowane

42
Q

VPMADDUBSW

A

vpmaddubsw xmm1, xmm2, xmm3/m128
vpmaddubsw ymm1, ymm2, ymm3/m256 (AVX2)
Mnoży bajty bez znaku z rejestru xmm2/ymm2 przez bajty z rejestru xmm3/m128 / ymm3/m256,
iloczyny są słowami, następnie dwa kolejne słowa dodaje horyzontalnie i zapisuje z nasyceniem, jako słowa
w rejestrze celu xmm1/ymm1.
cel[i] = źródło1[2i] * źródło2[2i] + źródło1[2i+1] * źródło2[2i+1]
xmm1[i] = xmm2[2i] * xmm3/m128[2i] + xmm2[2i+1] * xmm3/m128[2i+1]
ymm1[i] = ymm2[2i] * ymm3/m128[2i] + ymm2[2i+1] * ymm3/m128[2i+1]

Bity od 128/256 do MSB są zerowane

43
Q

VPMAX[U/S][B/W/D]

A

vpmax[u/s][b/w/d] xmm1, xmm2, xmm3/m128
vpmax[u/s][b/w/d] ymm1, ymm2, ymm3/m256 (AVX2)
Porównuje bez znaku/ze znakiem wartości w wektorach bajtów/słów/podwójnych słów rejestru
xmm2/ymm2 z odpowiednimi wartościami xmm3/ymm3 lub pamięci m128/m256, wektory wartości
maksymalnych są zapisywane w rejestrze xmm1/ymm1.
if źródło1[i] > źródło2[i] then cel[i] = źródło1[i] else cel[i] = źródło2[i]
if xmm2/ymm2[i] > xmm3||m128[i] / ymm3||m256[i]
then xmm1/ymm1[i] = xmm2/ymm2[i]
else xmm1/ymm1[i] = xmm3||m128[i] / ymm3||m256[i]

Bity od 128/256 do MSB są zerowane

44
Q

VPAVG[B/W]

A

vpavg[b/w] xmm1, xmm2, xmm3/m128
vpavg[b/w] ymm1, ymm2, ymm3/m256 (AVX2)
Zwraca średnią dwóch wartości bez znaku z wektorów bajtów/słów, dodaje wektory rejestru
xmm2/ymm2 z odpowiednimi wartościami xmm3/ymm3 lub pamięci m128/m256, sumę zaokrągla
jedynką oraz dzieli przez dwa poprzez przesuniecie bitowe o jeden w prawo, wynik zapisuje w rejestrze
xmm1/ymm1.
cel[i] = (źródło1[i] + źródło2[i] + 1)&raquo_space; 1
xmm1[i] = (xmm2[i] + xmm3/m128[i] + 1)&raquo_space; 1
ymm1[i] = (ymm2[i] + ymm3/m256[i] + 1)&raquo_space; 1

45
Q

VPSIGN[B/W/D]

A

vpsign[b/w/d] xmm1, xmm2, xmm3/m128
vpsign[b/w/d] ymm1, ymm2, ymm3/m256 (AVX2)
Zapisuje bajty/słowa/podwójne słowa do xmm1/ymm1 wartościami z rejestru xmm2
w zależności od znaku odpowiadającej wartości wektora w rejestrze xmm3/m128.
if źródło2[i] > 0; cel[i] = źródło1[i]
if źródło2[i] = 0; cel[i] = 0
if źródło2[i] < 0; cel[i] = - źródło1[i]

46
Q

VPCMPEQB, VPCMPEQW
VPCMPEQD, VPCMPGTB, VPCMPGTW
VPCMPGTD, VPCMPGTQ
co jest porównywane?
gdzie wpisywana jest wynik porównania?
jaki jest wynik?

A

xmm3/m128 z xmm2 do xmm1 prawda -1 fałsz 0
ymm3/m256 z ymm2 do ymm1 prawda -1 fałsz 0

47
Q

porównania ciągów znakowych

A

 Operacje porównania ciągów znakowych porównują w istocie liczby całkowite.
 Instrukcje te można podzielić na porównujące ciągi znakowe o, ustalonej (znanej)
w rejestrach [R/E]AX i [R/E]DX oraz nieznanej, długości.
 Instrukcje CMP na wyjściu tworzą indeks lub maskę, ale wynik porównania jest
zapisywany w [R/E]CX/xmm0 (brak w wywołaniu instrukcji).
 W instrukcjach tego typu istotne zadanie pełni bajt sterujący imm8, gdzie można
zdefiniować to złożone i wieloetapowe porównanie i pełni on w istocie funkcję
algorytmu instrukcji
 Instrukcje porównania jako nieliczne w AVX ustawiają f lagi

48
Q

VPSRLDQ, VPSRLV[D/Q]

A

vpsrldq xmm1, xmm2, imm8
vpsrldq ymm1, ymm2, imm8 (AVX2)
Przesuwa logicznie w prawo podwójne poczwórne słowo z rejestru xmm2/ymm2 o liczbę bajtów
określoną przez imm8. Podczas przesunięcia starsze bity są zerowane.
cel[i] = źródło1[i]&raquo_space; imm8
xmm1[i] = xmm2[i]&raquo_space; imm8
ymm1[i] = ymm2[i]&raquo_space; imm8

vpsrlv[d/q] xmm1, xmm2, xmm3/m128 (AVX2)
vpsrlv[d/q] ymm1, ymm2, ymm3/m256 (AVX2)
Przesuwa logicznie w prawo bity podwójne słowa/poczwórne słowa z rejestru xmm2/ymm2 o liczbę
bitów wskazaną przez odpowiednie elementy rejestru xmm3/ymm3 lub m128/m256 . Podczas przesunięcia
starsze bity są zerowane. Jeśli wartość licznika jest większa niż 31 dla podwójnych słów, 63 dla poczwórnych
słów, wówczas wszystkie bity są zerowane.
cel[i] = źródło1[i]&raquo_space; źródło2[i]
xmm1[i] = xmm2[i]&raquo_space; xmm3/m128[i]
ymm1[i] = ymm2[i]&raquo_space; ymm3/m128[i]

49
Q

VPANDN

A

vpandn xmm1, xmm2, xmm3/m128 (AVX)
vpandn ymm1, ymm2, ymm3/m256 (AVX2)
Oblicza iloczyn logiczny bit po bicie operendu2
xmm3/ymm3 lub m128/m256 oraz negacji
operendu1 xmm2/ymm2, wynik zapisuje w
xmm1/ymm1.
cel[i] = (not źródło1[i]) and źródło2[i]

50
Q

VZEROALL / VZEROUPPER

A

vzeroall (AVX)
Zeruje wszystkie rejestry ymm/0 - ymm/15
vzeroupper (AVX)
Zeruje bity od 128. do ostatniego rejestrów ymm/0 – ymm/15 / zmm/0 – zmm/15.
W trybie 32 bitowym zeruje tylko pierwsze 8 rejestrów

51
Q

VLDMXCSR / VSTMXCSR

A

 vldmxcsr m32 (AVX)
Ładuje zawartość operandu źródłowego m32 do rejestru kontrolnego i statusu (MXCSR Control and Status
Register), jest to ładowanie ustawień.
 vstmxcsr m32 (AVX)
Przesyła zawartość rejestru kontrolnego i statusu (MXCSR Control and Status Register) do operandu
źródłowego m32, jest to kopiowanie ustawień.

52
Q

VPALIGNR

A

vpalignr xmm1, xmm2, xmm3/m128, imm8 (AVX)
vpalignr ymm1, ymm2, ymm3/m256, imm8 (AVX2)
Łączy (konkatenacja) rejestry źródła xmm2/ymm2 i xmm3/ymm3 lub m128/m256, na podstawie bajtu
sterującego przesuwa 128 bitowe części o imm88 i zapisuje 128 bitowe części do rejestru celu xmm1/ymm1.
cel = (źródło1+źródło2)&raquo_space; źródło3
xmm1 = (xmm2+xmm3/m128)&raquo_space; imm8[7:0]8
hi ymm1 = (hi ymm2 +hi ymm3/m256)&raquo_space; imm8[7:0]8
lo ymm1 = (lo ymm2 + lo ymm3/m256)&raquo_space; imm8[7:0]8

53
Q

VAESENC, VAESENCLAST
VAESDEC, VAESDECLAST
VAESIMC, VAESKEYGENASSIST

A

vaesenclast xmm1, xmm2, xmm3/m128
Szyfruje jedną ale ostatnią rundą dane (blok danych) całego rejestru xmm2 (128 bitów) z wykorzystaniem
128 bitowego klucza zapianego w rejestrze xmm3/m128, zaszyfrowane dane zapisuje w rejestrze xmm1.

vaesimc xmm1, xmm2/m128
Dokonuje przekształcenia 128 bitowego klucza zapisanego w xmm2/m128 poprzez odwróconą funkcję
mieszania kolumn InvMixColumns(), wynik zapisuje w xmm1.
Funcja InvMixColumns() jest odwrotnością funkcji MixColumns().
cel = InvMixColumn(źródło-key)
xmm1 = InvMixColumn(xmm2/m128)

vaeskeygenassist xmm1, xmm2/m128 , imm8
Asystuje w rozszerzeniu klucza, poprzez obliczanie kroków w kierunku wygenerowania nowego klucza do
zaszyfrowania, używając RoundConstant (pełni funkcję klucza klucza) ma sposób zdefiniowany w bajcie
sterującym imm8, wynik zapisuje w rejestrze celu xmm1.
cel = szyfrowanie(źródło1-key), żródło2
xmm1 = syfrowanie(xmm2/m128), imm8

54
Q

VMOVS[S/D], VMOV[U/A]P[S/D]
VMOVNTP[S/D]

A
  1. vmovss xmm1, xmm2, xmm3
    Przepisuje z xmm2 do xmm1 liczbę pojedynczej
    precyzji pozostałe uzupełnia z xmm3.
    xmm1[31:0] ← xmm3[31:0]
    xmm1[127:32] ← xmm2[127:32}
  2. vmovss xmm1, m32
    Przepisuje liczbę rzeczywistą pojedynczej precyzji
    z pamięci m32 do rejestru xmm1.
    xmm1 ← m32
    xmm1[127:32] ← 0
  3. vmovss m32, xmm1
    Przesyła liczbę rzeczywistą pojedynczej
    precyzji (scalar) z xmm1 do pamięci m32.
    m32 ← xmm1[31:0]

vmov[u/a]p[s/d] xmm1, xmm2/m128
vmov[u/a]p [s/d] ymm1, ymm2/m256
Przesyła wektory liczb rzeczywistych pojedynczej/podwójnej precyzji bez wyrównania / z
wyrównaniem (U – unaligned / A – aligned) z xmm2/ymm2 lub m128/m256 do xmm1/ymm1.
cel ← źródło | xmm1/ymm1 ← xmm2/ymm2 lub m128/m256
vmov[u/a]p[s/d] xmm2/m128, xmm1
vmov[u/a]p[s/d] ymm2/m256, ymm1
Przesyła wektory liczb zmienno-przecinkowych pojedynczej/podwójnej precyzji bez wyrównania / z
wyrównaniem (U – unaligned / A - aligned) z xmm1/ymm1 do xmm2/ymm2 lub m128/m256.
cel ← źródło | xmm2/ymm2 lub m128/m256 ← xmm1/ymm1

vmovntp[s/d] m128, xmm1
vmovntp[s/d] m256, ymm1 (AVX2)
Przesyła wektor liczb rzeczywistych pojedynczej / podwójnej precyzji z rejestru xmm1/ymm1 do
pamięci m128/m256.
cel ← źródło
m128 ← xmm1
m256 ← ymm1
NT oznacza (non-temporal hint) przesłanie z pominięciem pamięci podręcznej (cache).

55
Q

VMOV[H/L]P[S/D]
VMOV[HL/LH]PS

A
  1. vmovhps xmm1, xmm2, m64
    Przesyła dwie wartościrzeczywiste pojedynczej precyzji z młodszej połowy xmm2 do młodszej połowy
    xmm1 oraz dwie wartości rzeczywiste z pamięci m64 do starszej połowy rejestru celu xmm1.
  2. vmovhps m64, xmm1
    Przesyła dwie wartości rzeczywiste pojedynczej precyzji ze starszej połowy xmm1 do pamięci m64.
  3. vmovhpd xmm2, xmm1, m64
    Kopiuje wartości liczb rzeczywistych podwójnej precyzji z młodszej połowy rejestru xmm1 oraz z
    pamięci m64, wynik zapisuje w xmm2.
  4. vmovhpd m64, xmm1
    Kopiuje liczbę rzeczywistą podwójnej precyzji ze starszej połowy xmm1 do pamięci m64.

vmovhlps xmm1, xmm2, xmm3
Przesyła ze starszej połowy rejestru xmm3 do młodszej połowy xmm1 oraz z starszej połowy
rejestru xmm2 do starszej połowy rejestru celu po dwie liczby rzeczywiste pojedynczej precyzji,
wynik zapisuje w xmm1.
vmovlhps xmm1, xmm2, xmm3
Przesyła z młodszej połowy rejestru xmm2 do młodszej połowy rejestru celu oraz ze młoszej połowy
rejestru xmm3 do starszej połowy rejestru celu po dwie liczby rzeczywiste pojedynczej precyzji,
wynik zapisuje w xmm1.

56
Q

VMOV[D/SH/SL]DUP

A

vmovddup xmm1, xmm2/m64
Kopiuje liczbę rzeczywistą podwójnej precyzji z rejestru xmm2 lub pamięci m64 do obu części rejestru
xmm1.
vmovddup ymm1, ymm2/m256
Kopiuje liczby rzeczywiste podwójnej precyzji o parzystych indeksach z rejestru ymm2 lub pamięci
m256 do ymm1.

vmovshdup xmm1, xmm2/m128
vmovshdup ymm1, ymm2/m256
Kopiuje z powieleniem wartości liczb rzeczywistych pojedynczej precyzji o nieparzystych indeksach
xmm2/ymm2 lub m128/m256 i zapisuje do xmm1/ymm1.
vmovsldup xmm1, xmm2/m128
vmovsldup ymm1, ymm2/m256
Kopiuje z powieleniem wartości liczb rzeczywistych pojedynczej precyzji o parzystych indeksach
xmm2/ymm2 lub m128/m256 i zapisuje do xmm1/ymm1.

57
Q

VMASKMOVPS

A

Przesyła liczby rzeczywiste pojedynczej precyzji z pamięci m128/m256 do rejestru celu xmm1/ymm1,
pod warunkiem, że bit znaku odpowiadających wartości z rejestru maski (drugi operand) xmm2/ymm2
lub xmm1/ymm1 jest ustawiony na jeden, w przeciwnym wypadku zapisuje zero.

vmaskmovps m128, xmm1, xmm2
vmaskmovps m256, ymm1, ymm2
Przesyła liczby rzeczywiste pojedynczej precyzji z rejestru xmm2/ymm2 do pamięci m128/m256 pod
warunkiem, że bit znaku odpowiadających wartości z rejestru maski (drugi operand) xmm1/ymm1 jest
ustawiony na jeden, w przeciwnym wypadku zapisuje zero

58
Q

VUNPCKLPS
VUNPCKLPD

VUNPCKHPS
VUNPCKHPD

A

vunpcklps xmm1, xmm2, xmm3/m128
vunpcklps ymm1, ymm2, ymm3/m256
Przepisuje liczby rzeczywiste pojedynczej precyzji. Młodszedwie liczby ze 128-bitowych części rejestru xmm2/ymm2
i xmm3/m128 / ymm3/m256 są zapisywane z przeplotemjako liczby rzeczywiste pojedynczej precyzji do rejestru
xmm1/ymm1.

vunpcklpd xmm1, xmm2, xmm3/m128
vunpcklpd ymm1, ymm2, ymm3/m256
Przepisuje liczby rzeczywiste podwójnej precyzji. Młodszeliczby ze 128-bitowych części rejestru
xmm2/ymm2 i xmm3/m128 / ymm3/m256 są zapisywane z przeplotem jako liczby rzeczywiste
podwójnej precyzji do rejestru xmm1/ymm1

vunpckhps xmm1, xmm2, xmm3/m128
vunpckhps ymm1, ymm2, ymm3/m256
Przepisuje liczby rzeczywiste pojedynczej precyzji. Starsze dwie liczby ze 128-bitowych części
rejestru xmm2/ymm2 i xmm3/m128 / ymm3/m256 są zapisywane z przeplotem jako liczby
rzeczywiste pojedynczej precyzji do rejestru celu xmm1/ymm1.

vunpckhpd xmm1, xmm2, xmm3/m128
vunpckhpd ymm1, ymm2, ymm3/m256
Przepisuje liczby rzeczywiste podwójnej precyzji. Starsze liczby ze 128-bitowych części rejestru
xmm2/ymm2 i xmm3/m128 / ymm3/m256 są zapisywane z przeplotem jako liczby rzeczywiste
podwójnej precyzji do rejestru celu xmm1/ymm1.

59
Q

VINSERTPS

A

vinsertps xmm1, xmm2, xmm3/m32, imm8
1. Kopiuje zawartość xmm2 do xmm1 oraz
2. Kopiuje element o indeksie imm8[7:6] z xmm3/m32
do rejestru xmm1 pod index imm8[5:4]
3. Zeruje elementy wektora xmm1 jeśli odpowiadające im bity imm8[3:0] są równe 1

60
Q

VINSERTF128

A

Kopiuje połowę rejestru ymm2 oraz cały rejestr xmm3/m128 liczb rzeczywistych zależnie od
najmłodszego bitu bajtu sterującego imm8[0].
na starszą lub młodszą część?

61
Q

VEXTRACTPS

A

vextractps reg/m32, xmm1, imm8
Wybiera z rejestru xmm1, liczbę rzeczywistą pojedynczej precyzji w oparciu o dwubitową wartość
imm8[1:0] stanowiącą offset (wielokrotność przesunięcia bitowego) i przesyła do rejestru ogólnego
przeznaczenia, (jeśli rejestr ma 64 bity. Wówczas starsza jego część jest zerowana) lub do pamięci.

62
Q

VEXTRACTF128

A

vextractf128 xmm1/m128, ymm2, imm8
Przesyła połowę rejestru ( 128 bitów) ymm2 liczb rzeczywistych pojedynczej lub podwójnej precyzji do
rejestru xmm1 lub do pamięci m128 według bajtu sterującego imm8.
młodszą czy starszą część

63
Q

VBLENDP[S/D], VBLENDVP[S/D]

A

Wybiera komplementarnie elementy wektorów liczb rzeczywistych pojedynczej/podwójnej precyzji, z
xmm3/ymm3 lub m128/m256 oraz xmm2/ymm2 według bajtu sterującego imm8, wynik zapisuje w
xmm1/ymm1. Kolejne bity imm8 odpowiadają kolejnym 32/64 bitom rejestrów/pamięci i pełnią zadanie
przełącznika.
i <o, 7> dla PS lub i <o, 3> dla PD
if imm8[i] = 0 then xmm1/ymm1[i] = xmm2/ymm2[i]
else xmm1/ymm1[i] = xmm3/ymm3[i] lub m128/m256[i]

vblendvp[s/d] xmm1, xmm2, xmm3/m128, xmm4
vblendvp[s/d] ymm1, ymm2, ymm3/m256, ymm4
Warunkowo kopiuje elementy wektorów liczb rzeczywistych pojedynczej/podwójnej precyzji, z
xmm3/ymm3 lub m128/m256 oraz xmm2/ymm2 według maski rejestru xmm4/ymm4, wynik zapisuje w
xmm1/ymm1. Maską są odpowiadające poszczególnym wektorom bity znaku xmm4/ymm4.
if xmm4/ymm4[i][31/63] = 0
then xmm1/ymm1[i] = xmm2/ymm2[i]
else
xmm1/ymm1[i] = xmm3/ymm3[i] lub m128/m256[i]

według maski (bitów znaków)
z 3 jeśli 1 z 2 jeśli 0

64
Q

VBROADCASTS[S/D] / VBROADCASTF128

A

vbroadcastss xmm1, m32/xmm2
vbroadcastss ymm1, m32/xmm2
Przesyła liczbę rzeczywistą pojedynczej precyzji z pamięci m32 lub najmłodszą z rejestru xmm2 do
całego rejestru celu xmm1/ymm1.
vbroadcastsd ymm1, m64
vbroadcastsd ymm1, xmm2
Przesyła liczbę rzeczywistą podwójnej precyzji z pamięci m64 lub najmłodszą z rejestru xmm2 do całego
rejestru celu xmm1/ymm1.
vbroadcastf128 ymm1, m128
Przesyła zawartość pamięci m128 do całego rejestru celu ymm1.

(ogólnie jedną liczbę do wszystkich komurek0

65
Q

VGATHER[D/Q]P[S/D]

A

vgather[d/q]p[s/d] xmm1, vm[32/64]x, xmm3 (AVX2)
vgather[d/q]p[s/d] ymm1, vm[32/64]y, ymm3 (AVX2)
Instrukcja kompletuje wektor xmm1/ymm1 używając adresów w postaci podwójnych/poczwórnych
słów zdefiniowanych w vm32[x/y]/vm64[x/y] używając jako indeksów podwójnych/poczwórnych słów
zapisanych w xmm2/ymm2 do wskazanej lokalizacji pamięci, skąd pobierane są liczby rzeczywiste
pojedynczej/podwójnej precyzji.
Pobierane z pamięci wartości są zapisywane do rejestru celu xmm1/ymm1 tylko wówczas gdy najstarsze
bity odpowiednich elementów wektora maski xmm3/ymm3 są równe 1.

W opisie instrukcji vm32x wskazuje wektor czterech 32-bitowych indeksów zapisanych w xmm2,
vm32y wektor ośmiu 32- bitowych indeksów dla ymm2.
Notacja vm64x i vm64y wskazuje analogicznie na maksymalnie dwa lub cztery indeksy.

Działanie instrukcji gather:
Pobiera z pamięci o wskazanej lokalizacji określonej tu jako adres_fizyczny liczby
pojedynczej/podwójnej precyzji i zapisuje je do rejestru celu ymm1/xmm1 tylko wówczas gdy bit znaku
odpowiadającego elementu maski ymm3/xmm3 jest równy jeden, jeśli bit znaku jest równy zero w
rejestrze celu zostaje wartość poprzednia. Po wykonaniu operacji pobierania z pamięci elementy maski
są zerowane

66
Q

VPERMP[S/D]

A

vpermps ymm1, ymm2, ymm3/m256
Wybiera liczby rzeczywiste pojedynczej precyzji z ymm3/m256 według wskazań ymm2 (trzy najmłodsze
bity każdego elementu wektora stanowią indeks), wynik zapisuje w ymm1.
ymm1[i] = ymm3/m256[ymm2[i][2:0]]
vpermpd ymm1, ymm2/m256, imm8
Wybiera liczby rzeczywiste podwójnej precyzji z ymm2/m256 według bajtu sterującego imm8, (kolejne
dwa bity), wynik zapisuje w ymm1.
ymm1[i] = ymm2/m256[imm8[2i+1:2i]]

67
Q

VPERMILPS
VPERMILPD

A

vpermilps xmm1, xmm2, xmm3/m128
vpermilps xmm1, xmm2/m128, imm8
vpermilps ymm1, ymm2, ymm3/m256
vpermilps ymm1, ymm2/m256, imm8
Wybiera liczby rzeczywiste pojedynczej precyzji z xmm2/ymm2 (/m128 /m256) według wskazania
odpowiadających dwóch najmłodszych bitów xmm3/m128 lub odpowiednich bitów imm8, wynik
zapisuje w xmm1/ymm1.

vpermilpd xmm1, xmm2, xmm3/m128
vpermilpd xmm1, xmm2/m128, imm8
vpermilpd ymm1, ymm2, ymm3/m256
vpermilpd ymm1, ymm2/m256, imm8
Wybiera liczby rzeczywiste podwójnej precyzji z xmm2/ymm2 (/m128 /m256) według wskazania
każdego drugiego bitu(o indeksie 1) z xmm3/m128, wynik zapisuje w xmm1/ymm1.

68
Q

VPERM2F128

A

vperm2f128 ymm1, ymm2, ymm3/m256, imm8
Wybiera odpowiednio 128 bitów liczb rzeczywistych z ymm2 oraz
ymm3/m256 według wskazania bajtu sterującego imm8,
wynik zapisuje w xmm1/ymm1.

69
Q

VSHUFPS VSHUFPD

A

vshufps xmm1, xmm2, xmm3/m256, imm8
vshufps ymm1, ymm2, ymm3/m256, imm8
Wybiera liczby rzeczywiste pojedynczej precyzji z xmm2/ymm2 oraz xmm3/ymm3 lub m128.m256 po
dwie z każdego źródła według bajtu sterującego imm8 i zapisuje w xmm1/ymm1 po dwie wartości
przeplatając źródła pochodzenia.

vshufpd ymm1, ymm2, ymm3/m256, imm8
Tasuje liczby rzeczywiste podwójnej precyzji z xmm2/ymm2 oraz xmm3/ymm3 lub m128 według bajtu
sterującego imm8. Wynik zapisuje w xmm1/ymm1 przeplatając źródła pochodzenia.
pojedyncze liczby, nie pary

70
Q

VADDS[S/D], VADDP[S/D], VHADDP[S/D]

A

vadds[s/d] xmm1, xmm2, xmm3/m32/m64
vaddp[s/d] xmm1, xmm2, xmm3/m128
vaddp[s/d] ymm1, ymm2, ymm3/m256
Dodaje skalary/wektory liczb rzeczywistych pojedynczej/podwójnej precyzji z rejestru xmm2/ymm2 i
xmm3/ymm3 lub m32/m64/m128/m256, wynik zapisuje w xmm1/ymm1. Dla skalarów pozostałe
elementy są przepisywane ze źródła 1.

vhaddps xmm1, xmm2, xmm3/m128
vhaddps ymm1, ymm2, ymm3/m256
Horyzontalne dodawanie sąsiednich liczb rzeczywistych pojedynczej precyzji i zapisywanie wyniku
z przeplotem co 64 bity
vhaddpd xmm1, xmm2, xmm3/m128
vhaddpd ymm1, ymm2, ymm3/m256
Horyzontalne dodawanie sąsiednich liczb rzeczywistych podwójnej precyzji i zapisywanie wyniku z
Przeplotem co 64 bity.

71
Q

VSUBS[S/D], VSUBP[S/D], VHSUBP[S/D]

A

VSUBS[S/D], VSUBP[S/D]
vsubs[s/d] xmm1, xmm2, xmm3/m32/m64
vsubp[s/d] xmm1, xmm2, xmm3/m128
vsubp[s/d] ymm1, ymm2, ymm3/m256
Od zawartości rejestru xmm2/ymm2 odejmuje liczby rzeczywiste pojedynczej/podwójnej precyzji
odpowiednio z xmm3/ymm3 lub m32/m64/m128/m256, wynik zapisuje w xmm1/ymm1. Dla skalarów
pozostałe elementy są przepisywane ze źródła 1.

vhsubps xmm1, xmm2, xmm3/m128
vhsubps ymm1, ymm2, ymm3/m256
Horyzontalne odejmowanie sąsiednich liczb rzeczywistych pojedynczej precyzji i
zapisywanie wyniku z przeplotem co 64 bity.

72
Q

VADDSUBP[S/D]

A

vaddsubp[s/d] xmm1, xmm2, xmm3/m128
vaddsubp[s/d] ymm1, ymm2, ymm3/m256
Naprzemiennie odejmuje i dodaje wektory liczb rzeczywistych pojedynczej/podwójnej precyzji od/do
zawartości rejestru xmm2/ymm2 odejmuje / dodaje odpowiadające wartości xmm3/ymm3 lub
m128/m256, wynik zapisuje w xmm1/ymm1.
ymm1[2i] = ymm2[2i] – ymm3/m256[2i]
ymm1[2i+1] = ymm2[2i+1] + ymm3/m256[2i+1]

73
Q

VMULS[S/D], VMULP[S/D]

A

vmuls[s/d] xmm1, xmm2, xmm3/m32/m64
vmulp[s/d] xmm1, xmm2, xmm3/m128
vmulp[s/d] ymm1, ymm2, ymm3/m256
Mnoży liczby rzeczywiste pojedynczej/podwójnej precyzji z rejestru xmm2/ymm2 odpowiednio przez
xmm3/ymm3 lub m32/m64/m128/m256, wynik zapisuje w xmm1/ymm1. Dla skalarów pozostałe
elementy pochodzą ze źródła 1.
xmm1[i] = xmm2[i] * xmm3/m128[i]
ymm1[i] = ymm2[i] * ymm3/m256[i]

74
Q

VDPPS
VDPPD

A

vdpps xmm1, xmm2, xmm3/m128, imm8
vdpps ymm1, ymm2, ymm3/m256, imm8
Oblicza iloczyn skalarny wektorów mnożąc warunkowo elementy rejestru xmm2 przez xmm3/mem, a
następnie warunkowo (zależnie od ustawień imm8[3…0]) zapisuje wynik lub 0 w xmm1.

vdppd xmm1,xmm2, xmm3/m128, imm8 (tylko na xmm)
Oblicza iloczyn skalarny wektorów mnoży warunkowo elementy rejestru xmm2 przez xmm3/m128, a
następnie sumuje iloczyny ustalając iloczyn skalarny, wynik, w zależności od bajtu sterującego zapisuje
w podanych w imm8[1,0] lokalizacjach xmm1.

75
Q

VDIVS[S/D]
VDIVP[S/D]

A

vdivs[s/d] xmm1, xmm2, xmm3/m32/m64
Dzieli liczby (skalary) rzeczywiste pojedynczej/podwójnej precyzji z rejestru xmm2/ymm2 odpowiednio
przez xmm3/ymm3 lub m32/m64, wynik zapisuje w xmm1/ymm1. Pozostałe elementy przepisuje z xmm2.

vdivp[s/d] xmm1, xmm2, xmm3/m128
vdivp[s/d] ymm1, ymm2, ymm3/m256
Dzieli wektory liczb rzeczywistych pojedynczej/podwójnej precyzji z rejestru xmm2/ymm2
odpowiednio przez xmm3/ymm3 lub m32/m64/m128/m256, wynik zapisuje w xmm1/ymm1.
xmm1[i] = xmm2[i] / xmm3/m128[i]
ymm1[i] = ymm2[i] / ymm3/m256[i]

76
Q

VMAXS[S/D], VMAXP[S/D]

A

vmaxs[s/d] xmm1, xmm2, xmm3/m32/m64
vmaxp[s/d] xmm1, xmm2, xmm3/m128
vmaxp[s/d] ymm1, ymm2, ymm3/m256
Zapisuje wartość maksymalną z porównania liczb rzeczywistych pojedynczej/podwójnej precyzji z
rejestrów xmm2/ymm2 i xmm3/ymm3 lub m32/m64/m128/m256 do xmm1/ymm1. Dla skalarów
pozostałe elementy pochodzą z xmm2.

77
Q

VMIN[S/P][S/D]

A

vmins[s/d] xmm1, xmm2, xmm3/m32/m64
vminp[s/d] xmm1, xmm2, xmm3/m128
vminp[s/d] ymm1, ymm2, ymm3/m256
Zwraca wartość minimalną z liczb rzeczywistych pojedynczej/podwójnej precyzji odpowiednio
skalary/wektory dla rejestrów xmm2/ymm2 i xmm3/ymm3 lub m32/m64/m128/m256, wynik zapisuje
do xmm1/ymm1. Dla skalarów pozostałe elementy pochodzą z xmm2.

78
Q

VROUND[S/P][S/D]

A

vroundss xmm1, xmm2, xmm3/m32, imm8
vroundsd xmm1, xmm2, xmm3/m64, imm8
Zaokrągla najmłodszą liczbę rzeczywistą pojedynczej/podwójnej precyzji z xmm3 lub m32/m64 do
wartości podwójnego/poczwórnego słowa (integer), wynik zapisuje w xmm1 jako liczbę rzeczywistą
pojedynczej precyzji (z przecinkiem i zerami po nim), pozostałe elementy pochodzą z xmm2,
sposób zaokrąglenia jest zdeterminowany bajtem sterującym imm8.
vroundp[s/d] xmm1, xmm2/m128, imm8
vroundp[s/d] ymm1, ymm2/m256, imm8
Zaokrągla wektor liczb rzeczywistych pojedynczej/podwójnej precyzji z xmm2/ymm2 lub m128/m256
do liczb całkowitych podwójnych/poczwórnych słów, wynik zapisuje jako liczby rzeczywiste w
xmm1/ymm1, zaokrąglenie odbywa się według bajtu sterującego imm8.
Bity od 128/256 do MSB są zerowane.

np. imm8 = 0000 0 0 00
P Precision Mask; 0. normal 1. inexact (niedokładny)
RS Rounding select (wybór zaokrąglenia) 1. MXCSR.RC 0. imm8.RC
RC Rounding mode (sposób zaokrąglenia)
RC Rounding mode:
00 - Zaokrąglij do najbliższej (parzystej)
01 - Zaokrąglij w dół (w kierunku −∞)
10 – Zaokrąglij w górę ( w kierunku +∞)
11 - Zaokrąglij do zera (obetnij)

79
Q

VRCP[SS/PS]

A

vrcpss xmm1, xmm2, xmm3/m32
Oblicza przybliżoną wartość odwrotności liczby rzeczywistej pojedynczej precyzji z xmm3/m32 i
wynik umieszcza w xmm1, dodatkowo przepisuje starsze elementy xmm2 do xmm1.
(Relative Error ≤ 1,5 *2^-12.)
xmm1[31:0] ← 1.0/xmm3/m32[31:0]
xmm1[127:32] ← xmm12[127:32]
vrcpps xmm1, xmm2/m128
vrcpps ymm1, ymm2/m256
Oblicza przybliżoną wartość odwrotności elementów wektora liczb rzeczywistych pojedynczej precyzji z
xmm2/ymm2 lub m128/m256 , wynik umieszcza w xmm1/ymm1. (Relative Error ≤ 1,5 *2^-12.)
xmm1[i] ← 1.0/xmm3/m128[i]
ymm1[i] ← 1.0/ymm3/m256[i]
Bity od 128/256 do MSB są zerowane.

80
Q

VRSQRTSS / VRSQRTPS

A

vrsqrtss xmm1, xmm2, xmm3/m32
Oblicza przybliżoną odwrotność pierwiastka z liczby rzeczywistej pojedynczej precyzji, wynik
umieszcza w xmm1, dodatkowo przepisuje starsze elementy xmm2 do xmm1.(Relative Error ≤ 1,5 *2^-12.)
xmm1[31:0] ← 1.0/sqrt(xmm3/m32[31:0])
xmm1[127:32] ← xmm12[127:32]
vrsqrtps xmm1, xmm2/m128
vrsqrtps ymm1, ymm2/m256
Oblicza przybliżoną odwrotność pierwiastka z elementów wektora liczb rzeczywistych pojedynczej
precyzji xmm2/ymm2 lub m128/m256, wynik umieszcza w xmm1/ymm1. (Relative Error ≤ 1,5 *2^-12.)
xmm1[i] ← 1.0/sqrt(xmm3/m128[i])
ymm1[i] ← 1.0/sqrt(ymm3/m256[i])

81
Q

VSQRT[S/P][S/D]

A

vsqrtss xmm1, xmm2, xmm3/m32
vsqrtsd xmm1, xmm2, xmm3/m64
Oblicza wartość pierwiastka kwadratowego z liczby rzeczywistej pojedynczej/podwójnej precyzji
xmm3/m32, wynik umieszcza w xmm1, dodatkowo przepisuje starsze elementy xmm2 do xmm1.
xmm1[0] ← sqrt(xmm3[0]/m32/m64)
xmm1[i] ← xmm2[i]
vsqrtp[s/d] xmm1, xmm2/m128
vsqrtp[s/d] ymm1, ymm2/m256
Oblicza wartość pierwiastka kwadratowego z elementów wektora liczb rzeczywistych pojedynczej
/podwójnej precyzji xmm2/ymm2 lub m128/m256, wynik zapisuje w xmm1/ymm1.
xmm1[i] ← sqrt(xmm3/m128[i])
ymm1[i] ← sqrt(ymm3/m256[i])
Bity od 128/256 do MSB są zerowane.

82
Q

VFMADD[132/213/231][S/P][S/D]
VFMSUB[132/213/231][S/P][S/D]

VFNMADD[132/213/231][S/P][S/D]
VFNMSUB[132/213/231][S/P][S/D]

A

Mnoży skalary / wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów i dodaje
odpowiednie wartości trzeciego rejestru w zależności od podanej kolejności, pierwsze dwie cyfry
oznaczają czynniki iloczynu, trzecia cyfra jest składnikiem sumy, wynik zapisuje w xmm1/ymm1.
132
ymm1[i] = ymm1[i] * ymm3/m256[i] + ymm2[i]
231
ymm1[i] = ymm2[i] * ymm3/m256[i] + ymm1[i]
213
ymm1[i] = ymm2[i] * ymm1[i] + ymm3/m256[i]

vfmsub[132/231/231]S[S/D] xmm1, xmm2, xmm3/m32/m64
vfmsub[132/231/231]P[S/D] xmm1, xmm2, xmm3/m128
vfmsub[132/231/231]P[S/D] ymm1, ymm2, ymm3/m256
Mnoży skalary / wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów i
odejmuje odpowiednie wartości trzeciego rejestru w zależności od podanej kolejności, pierwsze dwie
cyfry oznaczają czynniki iloczynu, trzecia cyfra jest elementem różnicy, wynik zapisuje w xmm1/ymm1.
132
ymm1[i] = ymm1[i] * ymm3/m256[i] - ymm2[i]
231
ymm1[i] = ymm2[i] * ymm3/m256[i] - ymm1[i]
213
ymm1[i] = ymm2[i] * ymm1[i] - ymm3/m256[i]

vfnmadd[132/231/231]S[S/D] xmm1, xmm2, xmm3/m32/m64
vfnmadd[132/231/231]P[S/D] xmm1, xmm2, xmm3/m128
vfnmadd[132/231/231]P[S/D] ymm1, ymm2, ymm3/m256
Mnoży skalary / wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów,
zmienia znak iloczynów i dodaje odpowiednie wartości trzeciego rejestru w zależności od podanej
kolejności, pierwsze dwie cyfry oznaczają czynniki iloczynu, trzecia cyfra jest składnikiem sumy, wynik
zapisuje w xmm1/ymm1.
132
ymm1[i] = -ymm1[i] * ymm3/m256[i] + ymm2[i]
231
ymm1[i] = -ymm2[i] * ymm3/m256[i] + ymm1[i]
213
ymm1[i] = -ymm2[i] * ymm1[i] + ymm3/m256[i]

vfnmsub[132/231/231]S[S/D] xmm1, xmm2, xmm3/m32/m64
vfnmsub[132/231/231]P[S/D] xmm1, xmm2, xmm3/m128
vfnmsub[132/231/231]P[S/D] ymm1, ymm2, ymm3/m256
Mnoży skalary / wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów,
zmienia znak iloczynów i odejmuje odpowiednie wartości trzeciego rejestru w zależności od podanej
kolejności, pierwsze dwie cyfry oznaczają czynniki iloczynu, trzecia cyfra jest elementem różnicy, wynik
zapisuje w xmm1/ymm1.
132
ymm1[i] = -ymm1[i] * ymm3/m256[i] - ymm2[i]
231
ymm1[i] = -ymm2[i] * ymm3/m256[i] - ymm1[i]
213
ymm1[i] = -ymm2[i] * ymm1[i] - ymm3/m256[i]

83
Q

VFMADDSUB[132/213/231]P[S/D]
VFMSUBADD[132/213/231]P[S/D]

A

VFMADDSUB[132/213/231]P[S/D]
vfmaddsub[132/231/231]p[s/d] xmm1, xmm2, xmm3/m128
vfmaddsub[132/231/231]p[s/d] ymm1, ymm2, ymm3/m256
Mnoży wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów i naprzemiennie odejmuje i dodaje
odpowiednie wartości trzeciego rejestru w zależności od podanej kolejności, pierwsze dwie cyfry oznaczają czynniki
iloczynu, trzecia cyfra jest elementem różnicy/sumy, wynik zapisuje w xmm1/ymm1.
132
ymm1[2i] = ymm1[2i] * ymm3/m256[2i] – ymm2[2i]
ymm1[2i+1] = ymm1[2i+1] * ymm3/m256[2i+1] + ymm2[2i+1]
231
ymm1[2i] = ymm2[2i] * ymm3/m256[2i] - ymm1[2i]
ymm1[2i+1] = ymm2[2i+1] * ymm3/m256[2i+1] + ymm1[2i+1]
213
ymm1[2i] = ymm2[2i] * ymm1[2i] – ymm3/m256[2i]
ymm1[2i+1] = ymm2[2i+1] * ymm1[2i+1] + ymm3/m256[2i+1]

vfmsubadd[132/231/231]p[s/d] xmm1, xmm2, xmm3/m128
vfmsubadd[132/231/231]p[s/d] ymm1, ymm2, ymm3/m256
Mnoży wektory liczb rzeczywistych pojedynczej / podwójnej precyzji dwóch rejestrów i naprzemiennie dodaje i odejmuje
odpowiednie wartości trzeciego rejestru w zależności od podanej kolejności, pierwsze dwie cyfry oznaczają czynniki
iloczynu, trzecia cyfra jest elementem sumy/różnicy, wynik zapisuje w xmm1/ymm1.
132
ymm1[2i] = ymm1[2i] * ymm3/m256[2i] + ymm2[2i]
ymm1[2i+1] = ymm1[2i+1] * ymm3/m256[2i+1] - ymm2[2i+1]
231
ymm1[2i] = ymm2[2i] * ymm3/m256[2i] + ymm1[2i]
ymm1[2i+1] = ymm2[2i+1] * ymm3/m256[2i+1] - ymm1[2i+1]
213
ymm1[2i] = ymm2[2i] * ymm1[2i] + ymm3/m256[2i]
ymm1[2i+1] = ymm2[2i+1] * ymm1[2i+1] - ymm3/m256[2i+1]

84
Q

VCMPS[S/D], VCMPP[S/D]

A

vcmps[s/d] xmm1, xmm2 xmm3/m32/m64, imm8
vcmpp[s/d] xmm1, xmm2 xmm3/m128, imm8
vcmpp[s/d] ymm1, ymm2, ymm3/m256, imm8
Porównuje skalary/wektory liczb rzeczywistych pojedynczej/podwójnej precyzji xmm2/ymm2 i
xmm3/ymm3 lub m32/m64/m128/m256 według funktora zapisanego na bitach imm8[4:0] (łącznie 32
funktory), wynik jako liczbę całkowitą -1 lub 0 zapisuje w xmm1/ymm1. Dla skalarów pozostałe
elementy są kopiowane ze źródła1.

85
Q

VCOMIS[S/D] / VUCOMIS[S/D]

A

vcomis[s/d] xmm1, xmm2/m32/m64
Porównuje pojedyncze liczby rzeczywiste pojedynczej/podwójnej precyzji z rejestru xmm2 lub pamięci
m32/m64 i xmm1 wynikiem jest ustawienie odpowiednich flag procesora. Instrukcja VCOMISD
sygnalizuje wyjątek nieprawidłowej operacji zmiennoprzecinkowej SIMD (#I) gdy operandem
źródłowym jest QNaN lub SNaN.

vcomis[s/d] xmm1, xmm2/m32/m64
Porównuje pojedyncze liczby rzeczywiste pojedynczej/podwójnej precyzji z rejestru xmm2 lub pamięci
m32/m64 i xmm1, wynikiem jest ustawienie odpowiednich flag procesora. Instrukcja VUCOMISD
sygnalizuje wyjątek nieprawidłowej operacji tylko wtedy, gdy operandem źródłowym jest SNaN

86
Q

VTESTP[S/D]

A

vtestp[s/d] xmm1, xmm2/m128
vtestp[s/d] ymm1, ymm2/m256
Wykonuje logicznie koniunkcję (AND) na bitach znaku liczb rzeczywistych pojedynczej /
podwójnej precyzji z rejestru xmm1/ymm1 i xmm2/ymm2 lub m1128/m256, wynikiem jest ustawienie
flagi ZF, jeśli wszystkie bity znaku = 0 => ZF = 1 lub ZF = 0 w przeciwnym przypadku
oraz jednocześnie
wykonuje logicznie koniunkcję z zaprzeczeniem (AND NOT)(nie cel i źródło) na bitach znaku
liczb rzeczywistych pojedynczej / podwójnej precyzji z rejestru xmm1/ymm1 i xmm2/ymm2 lub
m1128/m256, wynikiem jest ustawienie flagi CF, jeśli wszystkie bity znaku = 0 => CF=1, jeśli nie to CF=0.

87
Q

VCVTDQ2[PS/PD],VCVTSI2[SS/SD]

A

vcvtdq2ps xmm1, xmm2/m128
vcvtdq2ps ymm1, ymm2/m256
vcvtdq2pd xmm1, xmm2/m64
vcvtdq2pd ymm1, xmm2/m128
Konwertuje dwa/cztery/osiem podwójnych słów ze znakiem z xmm2/ymm2 lub m128/m256 na
dwie/cztery/osiem liczb rzeczywistych pojedynczej/podwójnej precyzji, wynik zapisuje do rejestru celu
xmm1/ymm1. Konwertuje zawsze dwa/dwa, cztery/cztery, osiem/osiem.

vcvtsi2ss xmm1, xmm2, reg/m32
vcvtsi2sd xmm1, xmm2, reg/m64
Konwertuje pojedyncze podwójne słowo ze znakiem z rejestru ogólnego przeznaczenia lub m32/m64
na jedną liczbę rzeczywistą pojedynczej/podwójnej precyzji, wynik zapisuje do xmm1/ymm1, bity
[127:64/32] są przepisywane z xmm2/ymm2.

88
Q

VCVT[PS/PD]2DQ ,VCVT[SS/SD]2SI
VCVTT[PS/PD]2DQ, VCVTT[SS/SD]2SI

A

vcvt[t]ps2dq xmm1, xmm2/m128
vcvt[t]ps2dq ymm1, ymm2/m256
Konwertuje cztery/osiem pojedynczych słów ze znakiem z xmm2/ymm2 lub m128/m256 na
cztery/osiem podwójnych słów ze znakiem, wynik zapisuje w xmm1/ymm1.
vcvt[t]pd2dq xmm1, xmm2/m128
vcvt[t]pd2dq ymm1, ymm2/m256
Konwertuje dwa/cztery pojedyncze słowa ze znakiem z xmm2/ymm2 lub m128/m256 na dwa/cztery
podwójne słowa ze znakiem, wynik zapisuje w xmm1/ymm1.
Zwrócona wartość jest zaokrąglana zgodnie z bitami kontrolnymi zaokrąglania w rejestrze MXCSR lub
dla [T] obcięta kierunku zera.

vcvt[t]ss2si reg32, xmm1/m32
vcvt[t]ss2si reg64, xmm1/m64
Konwertuje liczbę pojedynczej precyzji z xmm1 lub pomięci m32/m64 na podwójne/poczwórne słowo ze
znakiem, wynik zapisuje w rejestrze ogólnego przeznaczenia r32/r64.
vcvt[t]sd2si reg32, xmm1/m64
vcvt[t]sd2si reg64, xmm1/m64
Konwertuje liczbę podwójnej precyzji z xmm1 lub m32/m64 na podwójne/poczwórne słowo ze znakiem,
wynik zapisuje w rejestrze ogólnego przeznaczenia r32/r64.
Instrukcja z T oznacza konwersję z obcięciem w kierunku zera

vcvtsd2ss xmm1, xmm2, xmm3/m64
Konwertuje liczbę podwójnej precyzji z xmm3/m64 na liczbę pojedynczej precyzji, wynik umieszcza w
xmm1, starsze bity xmm1 są uzupełniane z xmm2.
vcvtss2sd xmm1, xmm2, xmm3/m32
Konwertuje liczbę pojedynczej precyzji z xmm3/m32 na liczbę podwójnej precyzji, wynik umieszcza w
xmm1, starsze bity xmm1 są uzupełniane z xmm2.

89
Q

VCVTSD2SS / VCVTSS2SD

VCVTPD2PS / VCVTPS2PD

A

vcvtsd2ss xmm1, xmm2, xmm3/m64
Konwertuje liczbę podwójnej precyzji z xmm3/m64 na liczbę pojedynczej precyzji, wynik umieszcza w
xmm1, starsze bity xmm1 są uzupełniane z xmm2.
vcvtss2sd xmm1, xmm2, xmm3/m32
Konwertuje liczbę pojedynczej precyzji z xmm3/m32 na liczbę podwójnej precyzji, wynik umieszcza w
xmm1, starsze bity xmm1 są uzupełniane z xmm2.

vcvtpd2ps xmm1, xmm2/m128
vcvtpd2ps xmm1, ymm2/m256
Konwertuje wektor liczb rzeczywistych podwójnej precyzji na wektor liczb rzeczywistych pojedynczej
precyzji. Konwertuje dwa na dwa elementy lub cztery na cztery elementy.
vcvtps2pd xmm1, xmm2/m64
vcvtps2pd ymm1, xmm2/m128
Konwertuje wektor liczb rzeczywistych pojedynczej precyzji na wektor liczb rzeczywistych podwójnej
precyzji. Konwertuje dwa na dwa elementy lub cztery na cztery elementy.

POPRAWA (5 decks)

Brainscape helps you reach your goals faster, through stronger study habits.
© 2024 Bold Learning Solutions. Terms and Conditions