nisko Flashcards
FINCSTP
FDECSTP
FFREE
FINIT
FNINIT
FCLEX
FNCLEX
FSTCW
FNSTCW
FLDCW
FSTENV
FNSTENV
FLDENV
FSAVE
FNSAVE
FRSTOR
FSTSW
FNSTSW
WAIT/FWAIT
FNOP
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
FXSAVE
FXRSTOR
EMMS
LDMXCSR
STMXCSR
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
PAVGB
PAVGW
PEXTRW
PINSRW
PMAXUB
PMAXSW
PMINUB
PMINSW
PMOVMSKB
PMULHUW
PSADBW
PSHUFW
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
XGETBV
Czyta do edx:eax zawartość rozszerzonego rejestru
kontrolnego o indeksie ecx.
FCOM
FCOMI
FICOM
FCOM - przecinki flagi c0,c1 itd
FCOMI - przecinki + eflags
FICOM - całkowite
LOCK
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
VMOV[D/Q]
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
VMOVDQ[A/U]
do ilu wyrownanie?
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
VMOVNTDQ[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).
VLDDQU
vlddqu xmm1, m128
vlddqu ymm1, m256
Ładuje 256/128 bitowe dane całkowite z niewyrównanej pamięci do rejestru celu
VPMOVMSKB
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.
VPMOV[S/Z]XB[W/D/Q], VPMOV[S/Z]XW[D/Q]
VPMOV[S/Z]XDQ
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
VMASKMOVDQU
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
VPMASKMOV[D/Q]
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
VPACK[S/U]SWB
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.
VPACK[S/U]SDW
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
VPUNPCKLBW
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
VPUNPCKHBW
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.
VEXTRACTI128
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.
VINSERTI128
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
VPSHUFB
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]
}
VPSHUFD
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
VPSHUFLW
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
VPERMD
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.
VPERMQ
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.
VPERM2I128
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.
VPBLENDVB
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
VPBLENDW
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
VPBLENDD
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
VPGATHER[D/Q][D/Q]
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])]
Różnica pomiędzy instrukcjami
gather a blend/perm/shuf
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).
VPADDUS[B/W]
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
VPHADDW / VPHADDD / VPHADDSW
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.
VPHSUBW / VPHSUBD / VPHSUBSW
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
VPSADBW
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
VPMULL[W/D]
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
VPMULHW
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])
VPMULHRSW
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]»_space; 14) + 1)»_space; 1
xmm1[i] = ((xmm2[i] * xmm3/m128[i]»_space; 14) + 1)»_space; 1
ymm1[i] = ((ymm2[i] * ymm3/m256[i]»_space; 14) + 1)»_space; 1
120
VPMULHRSW
Bity od 128/256 do MSB są zerowane
VPMUL[U]DQ
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]
VPCLMULQDQ
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
VPMADDWD
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
VPMADDUBSW
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
VPMAX[U/S][B/W/D]
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
VPAVG[B/W]
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)»_space; 1
xmm1[i] = (xmm2[i] + xmm3/m128[i] + 1)»_space; 1
ymm1[i] = (ymm2[i] + ymm3/m256[i] + 1)»_space; 1
VPSIGN[B/W/D]
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]
VPCMPEQB, VPCMPEQW
VPCMPEQD, VPCMPGTB, VPCMPGTW
VPCMPGTD, VPCMPGTQ
co jest porównywane?
gdzie wpisywana jest wynik porównania?
jaki jest wynik?
xmm3/m128 z xmm2 do xmm1 prawda -1 fałsz 0
ymm3/m256 z ymm2 do ymm1 prawda -1 fałsz 0
porównania ciągów znakowych
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
VPSRLDQ, VPSRLV[D/Q]
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]»_space; imm8
xmm1[i] = xmm2[i]»_space; imm8
ymm1[i] = ymm2[i]»_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]»_space; źródło2[i]
xmm1[i] = xmm2[i]»_space; xmm3/m128[i]
ymm1[i] = ymm2[i]»_space; ymm3/m128[i]
VPANDN
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]
VZEROALL / VZEROUPPER
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
VLDMXCSR / VSTMXCSR
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ń.
VPALIGNR
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)»_space; źródło3
xmm1 = (xmm2+xmm3/m128)»_space; imm8[7:0]8
hi ymm1 = (hi ymm2 +hi ymm3/m256)»_space; imm8[7:0]8
lo ymm1 = (lo ymm2 + lo ymm3/m256)»_space; imm8[7:0]8
VAESENC, VAESENCLAST
VAESDEC, VAESDECLAST
VAESIMC, VAESKEYGENASSIST
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
VMOVS[S/D], VMOV[U/A]P[S/D]
VMOVNTP[S/D]
- 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} - vmovss xmm1, m32
Przepisuje liczbę rzeczywistą pojedynczej precyzji
z pamięci m32 do rejestru xmm1.
xmm1 ← m32
xmm1[127:32] ← 0 - 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).
VMOV[H/L]P[S/D]
VMOV[HL/LH]PS
- 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. - vmovhps m64, xmm1
Przesyła dwie wartości rzeczywiste pojedynczej precyzji ze starszej połowy xmm1 do pamięci m64. - 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. - 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.
VMOV[D/SH/SL]DUP
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.
VMASKMOVPS
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
VUNPCKLPS
VUNPCKLPD
VUNPCKHPS
VUNPCKHPD
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.
VINSERTPS
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
VINSERTF128
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ęść?
VEXTRACTPS
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.
VEXTRACTF128
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ęść
VBLENDP[S/D], VBLENDVP[S/D]
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
VBROADCASTS[S/D] / VBROADCASTF128
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
VGATHER[D/Q]P[S/D]
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
VPERMP[S/D]
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]]
VPERMILPS
VPERMILPD
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.
VPERM2F128
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.
VSHUFPS VSHUFPD
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
VADDS[S/D], VADDP[S/D], VHADDP[S/D]
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.
VSUBS[S/D], VSUBP[S/D], VHSUBP[S/D]
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.
VADDSUBP[S/D]
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]
VMULS[S/D], VMULP[S/D]
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]
VDPPS
VDPPD
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.
VDIVS[S/D]
VDIVP[S/D]
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]
VMAXS[S/D], VMAXP[S/D]
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.
VMIN[S/P][S/D]
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.
VROUND[S/P][S/D]
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)
VRCP[SS/PS]
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.
VRSQRTSS / VRSQRTPS
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])
VSQRT[S/P][S/D]
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.
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]
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]
VFMADDSUB[132/213/231]P[S/D]
VFMSUBADD[132/213/231]P[S/D]
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]
VCMPS[S/D], VCMPP[S/D]
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.
VCOMIS[S/D] / VUCOMIS[S/D]
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
VTESTP[S/D]
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.
VCVTDQ2[PS/PD],VCVTSI2[SS/SD]
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.
VCVT[PS/PD]2DQ ,VCVT[SS/SD]2SI
VCVTT[PS/PD]2DQ, VCVTT[SS/SD]2SI
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.
VCVTSD2SS / VCVTSS2SD
VCVTPD2PS / VCVTPS2PD
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.
