Obsah
1. SIMD instrukce na platformě 80×86: instrukční sada MMX
2. První demonstrační příklad: detekce podpory technologie MMX
3. Součty vektorů, jejichž prvky mají šířku 16 nebo 32 bitů
4. Druhý demonstrační příklad: součet vektorů s prvky šířky 16 bitů
5. Třetí demonstrační příklad: součet vektorů s prvky šířky 32 bitů
6. Práce se 64bitovými celočíselnými hodnotami
7. Chování instrukcí součtu při přetečení
9. Demonstrační příklad: osmibitové a šestnáctibitové součty se saturací
11. Ukázka operací rozdílu pro různé typy vektorů
12. Součin vektorů prvek po prvku: netriviální operace
13. Součin vektorů se šestnáctibitovými prvky
14. Součin vektorů v případě, že výsledky přesáhnou 16bitový rozsah
15. Instrukce kombinující součin prvků vektorů se součtem mezivýsledků
16. Demonstrační příklad: použití instrukce PMADDWD
17. Logické operace s 64bitovými vektory
18. Seznam popsaných instrukcí MMX
19. Repositář s demonstračními příklady
1. SIMD instrukce na platformě 80×86: instrukční sada MMX
Na předchozí článek o vektorových instrukcích na platformě 80×86 dnes navážeme. Popíšeme si totiž další instrukce MMX, konkrétně všechny aritmetické instrukce, logické instrukce i instrukci, která kombinuje násobení prvků vektorů s jejich součtem. Příště pak celý popis MMX dokončíme popisem instrukcí pro provádění bitových rotací a posunů a především pak konverzních instrukcí (které jsou pro zpracování vektorů obecně velmi důležité a možná i nejvíce matoucí).
2. První demonstrační příklad: detekce podpory technologie MMX
Vyzkoušejme si nyní prakticky, jak může detekce podpory technologie MMX vypadat. V dnešním prvním demonstračním příkladu zavoláme instrukci CPUID pro získání informací kategorie 0 a 1. V prvním případě se v pracovních registrech vrátí označení mikroprocesoru, ve druhém případě získáme sadu 32bitových hodnot, přičemž nás budou zajímat hodnoty uložené do pracovního registru EDX, konkrétně hodnota bitu s indexem 32:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
;-----------------------------------------------------------------------------
section .bss
id_string: resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
; ziskani indexu nejvyssi volatelne funkce CPUID
xor eax, eax ; nulta kategorie
cpuid
mov edx, eax ; hodnota, ktera se ma vytisknout
mov ebx, hex_message ; buffer, ktery se zaplni hexa cislicemi
call hex2string ; zavolani prislusne subrutiny
print_string hex_message, hex_message_length ; tisk hexadecimalni hodnoty
; test podpory MMX
mov eax, 1 ; prvni kategorie
cpuid
mov ebx, hex_message ; buffer, ktery se zaplni hexa cislicemi
; EDX již obsahuje bity, které chceme vytisknout
call hex2string ; zavolani prislusne subrutiny
print_string hex_message, hex_message_length ; tisk hexadecimalni hodnoty
; vypis CPU ID
xor eax, eax ; nulta kategorie
cpuid
mov [id_string], ebx ; prvni ctyri znaky ID
mov [id_string+4], edx ; dalsi ctyri znaky ID
mov [id_string+8], ecx ; posledni ctyri znaky ID
print_string id_string, 12 ; tisk 12 znaku CPU ID
exit ; ukonceni procesu
%include "hex2string.asm"
V mém konkrétním případě se vytiskne následující trojice informací:
00000020 BFEBFBFF GenuineIntel
Z první hexadecimální hodnoty vyplývá, že nejvyšší kategorie informací, kterou lze pro tento mikroprocesor získat, je 0×20=32. Poslední řetězec složený z dvanácti znaků identifikuje výrobce (zde zřejmé) a prostřední 32bitová hodnota obsahuje mj. tyto informace:
- FPU je podporován (bit číslo 0)
- MMX je podporováno (bit číslo 23)
- SSE je podporováno (bit číslo 25)
- SSE2 je podporováno (bit číslo 26)
Poznámka: informace o podpoře vyšších verzí SSE či o podpoře AVX je možné získat z registru ECX, což si ukážeme příště.
3. Součty vektorů, jejichž prvky mají šířku 16 nebo 32 bitů
V předchozím článku jsme si ukázali především součet osmiprvkových vektorů, přičemž každý prvek těchto vektorů měl šířku osm bitů (tedy buď hodnota bez znaménka nebo se znaménkem). Připomeňme si, že běžný součet takových vektorů je realizován instrukcí PADDB a součet se saturací (namísto přetečení) pak instrukcemi PADDUSB (hodnoty bez znaménka) nebo PADDSB (hodnoty se znaménkem).
Podobně existují i MMX instrukce určené pro součet vektorů, jejichž prvky mají šířku šestnácti bitů nebo 32 bitů. Jedná se o tyto instrukce:
| # | Instrukce | Stručný popis instrukce |
|---|---|---|
| 1 | paddw | součet dvou čtyřprvkových vektorů, každý prvek má šířku šestnácti bitů |
| 2 | paddd | součet dvou dvouprvkových vektorů, každý prvek má šířku 32 bitů |
| 3 | paddsw | součet dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů se znaménkem |
| 4 | paddusw | součet dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů bez znaménka |
Poznámka: povšimněte si, že není možné sčítat se saturací 32bitové hodnoty, což je sice zvláštní, ale v praxi se součet/rozdíl se saturací týká především osmibitových a šestnáctibitových hodnot.
4. Druhý demonstrační příklad: součet vektorů s prvky šířky 16 bitů
Ukažme si ve stručnosti provedení součtu dvou vektorů, jejichž prvky mají šířku šestnáct bitů. To znamená, že každý vektor obsahuje čtyři prvky. Použitím instrukce PADDW je možné tyto čtyři prvky sečíst jedinou instrukcí, přičemž součet je proveden paralelně. A pochopitelně platí, že se neprovádí přenosy bitů (carry) mezi jednotlivými prvky (ty jsou od sebe v tomto kontextu izolovány):
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 db 1, 2, 3, 4, 5, 6, 7, 8
mmx_val_2 db 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
paddw mm1, mm2 ; soucet hodnot ve vektoru slovo po slove
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Po překladu a spuštění tohoto demonstračního příkladu by se měly vypsat následující hodnoty:
08070605 04030201 FBFBFBFB FBFBFBFB 04020200 FFFEFDFC
Vzhledem k tomu, že se provádí součet po šestnáctibitových slovech, je možné výpis interpretovat následovně:
první vektor: 0807 0605 0403 0201
druhý vektor: FBFB FBFB FBFB FBFB
-------------------
součet vektorů: 0402 0200 FFFE FDFC
Poznámka: u první a druhé dvojice prvků evidentně došlo k přetečení (výsledky jsou menší než vstupní operandy), to však nijak neovlivnilo ostatní prvky ani výsledek jejich součtu.
5. Třetí demonstrační příklad: součet vektorů s prvky šířky 32 bitů
Ve třetím demonstračním příkladu použijeme namísto instrukce PADDW instrukci PADDD. Poslední písmeno této instrukce naznačuje, že se namísto šestnáctibitových slov (word) budou sčítat vektory s 32bitovými dvojslovy (double word). Jinak se tento příklad žádným způsobem neodlišuje od předchozího příkladu, popř. od příkladů uvedených minule:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 db 1, 2, 3, 4, 5, 6, 7, 8
mmx_val_2 db 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
paddd mm1, mm2 ; soucet hodnot ve vektoru po dvouslovech
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Opět se podívejme na hodnoty vypsané tímto příkladem:
08070605 04030201 FBFBFBFB FBFBFBFB 04030200 FFFEFDFC
Jejich interpretace je snadná:
první vektor: 08070605 04030201
druhý vektor: FBFBFBFB FBFBFBFB
-----------------
součet vektorů: 04030200 FFFEFDFC
Poznámka: nepatrnou úpravou (jeden bajt se změní z 0×04 na 0×05) můžeme zjistit, jestli přetečení 32bitové hodnoty nižších prvků vektorů povede ke změně výsledků u druhé sady prvků:
08070605 05030201 FBFBFBFB FBFBFBFB 04030200 00FEFDFC
První sloupec hodnot se vůbec nezměnil, což znamená, že k přetečení (podle očekávání) nedochází.
6. Práce se 64bitovými celočíselnými hodnotami
Instrukce MMX na platformu 80×86 přinesly i možnost zpracování celočíselných hodnot o šířce celých 64 bitů, i když s omezeními (nenastavují se totiž příznakové bity). K tomuto účelu se používají instrukce končící na písmeno Q, které vzniklo ze sousloví quad words). MMX registry se v případě použití těchto instrukcí chovají nikoli tak, jakoby se jednalo o vektory, ale o skalární hodnoty (z toho prostého důvodu, že se více prvků do 64bitových registrů stejně nevejde). Podívejme se na základní MMX instrukci určenou pro součet dvojice 64bitových hodnot. Její použití je velmi snadné:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 db 1, 2, 3, 4, 5, 6, 7, 8
mmx_val_2 db 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
paddq mm1, mm2 ; soucet hodnot ve vektoru po ctyrslovech
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Výsledky získané po překladu a spuštění tohoto příkladu:
08070605 04030201 FBFBFBFB FBFBFBFB 04030200 FFFEFDFC
Neboli:
první hodnota: 0807060504030201
druhá hodnota: FBFBFBFBFBFBFBFB
----------------
součet hodnot: 04030200FFFEFDFC
7. Chování instrukcí součtu při přetečení
Ještě jednou si shrňme základní informace o instrukcích PADDB, PADDW, PADDD a PADDQ:
| Instrukce | Součet prvků typu | Počet prvků |
|---|---|---|
| PADDB | byte | 8+8 (vektory) |
| PADDW | 16 bitů | 4+4 (vektory) |
| PADDD | 32 bitů | 2+2 (vektory) |
| PADDQ | 64 bitů | 1+1 (skaláry) |
Při součtech vektorů se ignorují případné přenosy mezi sousedními prvky. Chování těchto instrukcí si ověříme na součtu dvou 64bitových slov, která budou chápána jako osmice bajtů, čtveřice 16bitových hodnot, dvojice 32bitových hodnot nebo 64bitové hodnoty:
mmx_val_1 db 1, 0, 0, 0, 0, 0, 0, 0 mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
Poznámka: povšimněte si, jak vhodně jsou tyto hodnoty zvoleny. V první 64bitové hodnotě je nastaven jen nejnižší bit (ostatní bity jsou nulové) zatímco v hodnotě druhé jsou nastaveny všechny bity. Při součtech tedy bude docházet k určitým formám přetečení, která se budou odlišovat podle toho, s jak širokými operandy se pracuje.
Obě osmice bajtů nejprve načteme do MMX registrů MM1 a MM2:
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
Dále si tyto hodnoty uložíme do „stálých“ registrů MM3 a MM4, které nebudou programem modifikovány (MMX se nechová jako zásobník):
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
Před jednotlivými operacemi PADDB, PADDW, PADDD a PADDQ zkopírujeme původní obsah registrů MM3 a MM4 do registrů MM1 a MM2. Příslušnou operaci součtu následně provedeme a výsledek v MM1 si necháme vytisknout:
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
paddb mm1, mm2 ; soucet hodnot ve vektoru bajt po bajtu
print_string paddb_message, paddb_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddw mm1, mm2 ; soucet hodnot ve vektoru bajt po slovech
print_string paddw_message, paddw_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddd mm1, mm2 ; soucet hodnot ve vektoru bajt po dvouslovech
print_string paddd_message, paddd_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddq mm1, mm2 ; soucet hodnot ve vektoru bajt po ctyrslovech
print_string paddq_message, paddq_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
Nyní se podívejme na výsledky. Nejprve budou uvedeny bez popisu tak, jak je vypíše program:
00000000 00000001 FFFFFFFF FFFFFFFF paddb: FFFFFFFF FFFFFF00 paddw: FFFFFFFF FFFF0000 paddd: FFFFFFFF 00000000 paddq: 00000000 00000000
Interpretace:
první vstupní operand: 00 00 00 00 00 00 00 01
druhý vstupní operand: FF FF FF FF FF FF FF FF
-----------------------
součet po bajtech: FF FF FF FF FF FF FF 00
přetečení: ^^
první vstupní operand: 0000 0000 0000 0001
druhý vstupní operand: FFFF FFFF FFFF FFFF
-------------------
součet po 16 bitech: FFFF FFFF FFFF 0000
přetečení: ^^^^
první vstupní operand: 00000000 00000001
druhý vstupní operand: FFFFFFFF FFFFFFFF
-----------------
součet po 32 bitech: FFFFFFFF 00000000
přetečení: ^^^^^^^^
první vstupní operand: 0000000000000001
druhý vstupní operand: FFFFFFFFFFFFFFFF
----------------
součet po 64 bitech: 0000000000000000
přetečení: ^^^^^^^^^^^^^^^^
Pro úplnost si uveďme celý zdrojový kód příkladu, který tyto hodnoty vytiskl:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
paddb_message:
db 0x0a, "paddb:", 0x0a
paddb_message_length equ $ - paddb_message
paddw_message:
db 0x0a, "paddw:", 0x0a
paddw_message_length equ $ - paddw_message
paddd_message:
db 0x0a, "paddd:", 0x0a
paddd_message_length equ $ - paddd_message
paddq_message:
db 0x0a, "paddq:", 0x0a
paddq_message_length equ $ - paddq_message
mmx_val_1 db 1, 0, 0, 0, 0, 0, 0, 0
mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
paddb mm1, mm2 ; soucet hodnot ve vektoru bajt po bajtu
print_string paddb_message, paddb_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddw mm1, mm2 ; soucet hodnot ve vektoru bajt po slovech
print_string paddw_message, paddw_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddd mm1, mm2 ; soucet hodnot ve vektoru bajt po dvouslovech
print_string paddd_message, paddd_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddq mm1, mm2 ; soucet hodnot ve vektoru bajt po ctyrslovech
print_string paddq_message, paddq_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
8. Součty se saturací
Vyzkoušejme si ještě, jaký je rozdíl v instrukcích PADDUSB a PADDUSW, které obě provádí součty se saturací. Nejprve se pokusíme sečíst hodnoty 0×01 a dále hodnotu, v níž jsou nastaveny všechny bity. Výsledky budou totožné, a to bez ohledu na to, jaká instrukce je použita pro součet:
paddusb: 00 00 00 00 00 00 00 01 FF FF FF FF FF FF FF FF ----------------------- FF FF FF FF FF FF FF FF paddusw: 0000 0000 0000 0001 FFFF FFFF FFFF FFFF ------------------- FFFF FFFF FFFF FFFF
Poznámka: vypsané hodnoty byly pro větší přehlednost ručně odděleny mezerami tam, kde začínají jednotlivé prvky vektorů.
Ovšem pro odlišné vstupy se již budou odlišovat i výsledky součtů se saturací:
paddusb: 00 04 00 03 00 02 00 01 00 FF 00 FF 00 FF 00 FF ----------------------- 00 FF 00 FF 00 FF 00 FF paddusw: 0004 0003 0002 0001 00FF 00FF 00FF 00FF ------------------- 0103 0102 0101 0100
paddusb: 00 00 00 01 00 01 00 01 00 00 FF FF 00 FF 00 FF ----------------------- 00 00 FF FF 00 FF 00 FF paddusw: 0000 0001 0001 0001 0000 FFFF 00FF 00FF ------------------- 0000 FFFF 0100 0100
Z těchto výsledků je patrné, že v prvním případě nikdy nedojde k přenosům mezi bajty, zatímco ve druhém případě k těmto přenosům dochází mezi lichými a sudými bajty (jinak pochopitelně nikoli).
9. Demonstrační příklad: osmibitové a šestnáctibitové součty se saturací
Celý zdrojový kód ukázkového příkladu, kterým jsme získali hodnoty z předchozí kapitoly, vypadá následovně:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
paddusb_message:
db 0x0a, "paddusb:", 0x0a
paddusb_message_length equ $ - paddusb_message
paddusw_message:
db 0x0a, "paddusw:", 0x0a
paddusw_message_length equ $ - paddusw_message
mmx_val_1 db 1, 0, 0, 0, 0, 0, 0, 0
mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
paddusb mm1, mm2 ; soucet hodnot ve vektoru bajt po bajtu
print_string paddusb_message, paddusb_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
paddusw mm1, mm2 ; soucet hodnot ve vektoru bajt po slovech
print_string paddusw_message, paddusw_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
10. Operace rozdílu
Kromě operací součtu nalezneme v instrukční sadě MMX i operace rozdílu. Repertoár těchto instrukcí je prakticky totožný s instrukcemi součtu, což je ostatně i patrné z následující tabulky:
| # | Instrukce součtu | Instrukce rozdílu | Prvky typu | Počet prvků |
|---|---|---|---|---|
| 1 | PADDB | PSUBB | byte | 8+8 (vektory) |
| 2 | PADDW | PSUBW | 16 bitů | 4+4 (vektory) |
| 3 | PADDD | PSUBD | 32 bitů | 2+2 (vektory) |
| 4 | PADDQ | 64 bitů | 1+1 (skaláry) | |
| 5 | PADDSB | PSUBSB | signed byte | 8+8 (vektory) |
| 6 | PADDSW | PSUBSW | signed 16 bitů | 4+4 (vektory) |
| 7 | PADDUSB | PSUBUSB | unsigned byte | 8+8 (vektory) |
| 8 | PADDUSW | PSUBUSW | unsigned 16 bitů | 4+4 (vektory) |
Poznámka: povšimněte si chybějící instrukce PSUBQ. Taková instrukce sice existuje, ale zavedena byla až v instrukční sadě SSE2.
11. Ukázka operací rozdílu pro různé typy vektorů
Některé výše popsané instrukce pro výpočet rozdílů vektorů budou ukázány v dalším demonstračním příkladu. Tento příklad provede operace PSUBB, PSUBW a PSUBD. Navíc je přidána i instrukce PSUBQ, která sice v MMX neexistuje, ale byla dodána společně s SSE2. Z jejího použití je zřejmé, že i tuto instrukci je možné použít společně s běžnými MMX registry (i s registry SSE, ale to již předbíháme):
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
psubb_message:
db 0x0a, "psubb:", 0x0a
psubb_message_length equ $ - psubb_message
psubw_message:
db 0x0a, "psubw:", 0x0a
psubw_message_length equ $ - psubw_message
psubd_message:
db 0x0a, "psubd:", 0x0a
psubd_message_length equ $ - psubd_message
psubq_message:
db 0x0a, "psubq:", 0x0a
psubq_message_length equ $ - psubq_message
mmx_val_1 db 1, 0, 0, 0, 0, 0, 0, 0
mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
psubb mm1, mm2 ; soucet hodnot ve vektoru bajt po bajtu
print_string psubb_message, psubb_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
psubw mm1, mm2 ; soucet hodnot ve vektoru bajt po slovech
print_string psubw_message, psubw_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
psubd mm1, mm2 ; soucet hodnot ve vektoru bajt po dvouslovech
print_string psubd_message, psubd_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
psubq mm1, mm2 ; soucet hodnot ve vektoru bajt po ctyrslovech
print_string psubq_message, psubq_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Podívejme se na výsledky, ke kterým byly ručně přidány poznámky:
první vektor: 00 00 00 00 00 00 00 01
druhý vektor: FF FF FF FF FF FF FF FF
-----------------------
psubb: 01 01 01 01 01 01 01 02
první vektor: 0000 0000 0000 0001
druhý vektor: FFFF FFFF FFFF FFFF
-------------------
psubw: 0001 0001 0001 0002
první vektor: 00000000 00000001
druhý vektor: FFFFFFFF FFFFFFFF
-----------------
psubd: 00000001 00000002
první vektor: 0000000000000001
druhý vektor: FFFFFFFFFFFFFFFF
----------------
psubq: 0000000000000002
Otočení operandů vede podle očekávání ke stejným výsledkům:
první vektor: FF FF FF FF FF FF FF FF
druhý vektor: 00 00 00 00 00 00 00 01
-----------------------
psubb: FF FF FF FF FF FF FF FE
první vektor: FFFF FFFF FFFF FFFF
druhý vektor: 0000 0000 0000 0001
-------------------
psubw: FFFF FFFF FFFF FFFE
první vektor: FFFFFFFF FFFFFFFF
druhý vektor: 00000000 00000001
-----------------
psubd: FFFFFFFF FFFFFFFE
první vektor: FFFFFFFFFFFFFFFF
druhý vektor: 0000000000000001
----------------
psubq: FFFFFFFFFFFFFFFE
12. Součin vektorů prvek po prvku: netriviální operace
Další operací, kterou je možné realizovat v instrukční sadě MMX, je součin vektorů stylem prvek po prvku. Pro tento účel jsou k dispozici dvě instrukce nazvané PMULLW a PMULHW. Tyto instrukce slouží pro součin vektorů se čtyřmi prvky, přičemž každý prvek má (pochopitelně) šířku šestnácti bitů. A proč jsou k dispozici dvě instrukce? První z nich uloží do cílového vektoru dolních šestnáct bitů součinů a druhá instrukce naopak horních šestnáct bitů. To v praxi znamená, že neexistuje jediná instrukce, která by vrátila čtyři 32bitové výsledky – takovou operaci je nutné provést po částech. A ještě zajímavější je, že násobit lze skutečně jen vektory se šestnáctibitovými hodnotami – nemáme k dispozici instrukce pro vynásobení osmibitových či 32bitových prvků (což je jedno z omezení, které bylo částečně odstraněno až v SSE 2).
Poznámka: opět platí, že výsledek součinu nijak neovlivní příznakové bity mikroprocesoru.
13. Součin vektorů se šestnáctibitovými prvky
Nejprve si ukážeme použití instrukce PMULLW, která slouží pro vynásobení dvojice vektorů, z nichž každý obsahuje čtyři prvky typu word, tj. šestnáctibitové hodnoty. Výsledkem je čtveřice 32bitových hodnot, přičemž do cílového registru se uloží jen spodních šestnáct bitů výsledků. Násobit však budeme jen malé hodnoty, takže k přetečení výsledků nedojde:
mmx_val_1 dw 1, 2, 3, 4 mmx_val_2 dw 2, 2, 2, 2
Očekávané výsledky jsou tedy 1, 4, 6 a 8.
Ověřme si tyto výsledky překladem a spuštěním příkladu:
první vektor: 0004 0003 0002 0001
druhý vektor: 0002 0002 0002 0002
-------------------
součin prvků: 0008 0006 0004 0002
Úplný zdrojový kód tohoto příkladu vypadá následovně:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 dw 1, 2, 3, 4
mmx_val_2 dw 2, 2, 2, 2
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
pmullw mm1, mm2 ; soucin hodnot ve vektoru slovo po slovu
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
14. Součin vektorů v případě, že výsledky přesáhnou 16bitový rozsah
V předchozí kapitole jsme si ukázali, jak vypadá součin prvků vektorů v případě, že výsledky nepřesáhnou rozsah šestnácti bitů. Nyní si situaci zkomplikujeme a použijeme tyto vstupní vektory:
mmx_val_1 dw 1, 2, 3, 4 mmx_val_2 dw 20000, 20000, 20000, 20000
Budeme tedy provádět součiny 1×20000, 2×20000, 3×20000 a 4×20000. V posledním případě bude výsledek větší než 65535 a tudíž se nevejde do šestnácti bitů. Výsledky pro operaci PMULLW budou vypadat následovně:
první vektor: 0004 0003 0002 0001
druhý vektor: 4E20 4E20 4E20 4E20
-------------------
součin prvků: 3880 EA60 9C40 4E20
přetečení: ^^^^
Naopak pro instrukci PMULHW, které do cílového vektoru ukládá vyšší slova, dostaneme následující výsledky:
první vektor: 0004 0003 0002 0001
druhý vektor: 4E20 4E20 4E20 4E20
-------------------
součin prvků: 0001 0000 0000 0000
přetečení: ^^^^
Další demonstrační příklad po svém překladu a spuštění vypíše první výsledky:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 dw 1, 2, 3, 4
mmx_val_2 dw 20000, 20000, 20000, 20000
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
pmullw mm1, mm2 ; soucin hodnot ve vektoru slovo po slovu
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Vyšší slova výsledků součinů naproti tomu získáme tímto příkladem:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
mmx_val_1 dw 1, 2, 3, 4
mmx_val_2 dw 20000, 20000, 20000, 20000
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
pmulhw mm1, mm2 ; soucin hodnot ve vektoru slovo po slovu
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
15. Instrukce kombinující součin prvků vektorů se součtem mezivýsledků
Nejsložitější instrukcí z instrukční sady MMX je instrukce, která dokáže provést součin prvků vektorů prvek po prvku a následně realizuje součet takto získaných mezivýsledků. Tato instrukce se jmenuje PMADDWD a vyžaduje si podrobnější popis. Oba zdrojové MMX registry, které tato instrukce zpracovává, musí obsahovat čtveřici šestnáctibitových hodnot. Nazvěme prvky obou vstupních vektorů [X3, X2, X1, X0] a [Y3, Y2, Y1, Y0]. V prvním kroku se provedou tyto výpočty: X3×Y3, X2×Y2, X1×Y1 a X0×Y0, přičemž výsledky jsou 32bitové. A v kroku druhém se vždy dvojice mezivýsledků sečte a vznikne vektor se dvěma 32bitovými hodnotami: [X3×Y3 + X2×Y2, X1×Y1 + X0×Y0]. Současně je tento vektor výsledkem celé instrukce.
Tuto instrukci lze využít například k míchání audio stereo signálu (a pravděpodobně právě k tomuto účelu byla navržena – tomu by odpovídal vstupní formát). Ovšem s trochou „dopomoci“ (konverze) je možné tuto instrukci použít i pro rastrové operace, při provádění lineárních transformací atd. Poněkud omezující je ovšem to, že jak formát vstupních vektorů, tak i formát výsledného vektoru je pevně daný a nelze například násobit (a sčítat) vektory obsahující bajty atd.
16. Demonstrační příklad: použití instrukce PMADDWD
V dnešním předposledním demonstračním příkladu použijeme instrukci PMADDWD pro různé vstupní vektory. Výpočet i zobrazení výsledků jsou provedeny v pomocném makru:
%macro perform_maddwd 2
emms ; inicializace MMX
mov ebx, %1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, %2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
pmaddwd mm1, mm2 ; soucin hodnot se souctem mezivysledku
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
print_string separator, separator_length
%endmacro
Podívejme se na jednotlivé výsledky. První dva řádky obsahují vstupní vektory (4×16 bitů), poslední řádek pak výstupní vektor (2×32 bitů):
Výpočet 4×1+3×1 a 2×1 + 1×1:
0004 0003 0002 0001 0001 0001 0001 0001 ------------------- 00000007 00000003
Výpočet 4×2+3×2 a 2×2 + 1×2:
0004 0003 0002 0001 0002 0002 0002 0002 ------------------- 0000000E 00000006
Výpočet 4×255+3×255 a 2×255 + 1×255:
0004 0003 0002 0001 00FF 00FF 00FF 00FF ------------------- 000006F9 000002FD
Výpočet 4×16384+3×16384 a 2×16384 + 1×16384:
0004 0003 0002 0001 4000 4000 4000 4000 ------------------- 0001C000 0000C000
Úplný zdrojový kód tohoto demonstračního příkladu vypadá následovně:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
separator:
db 0x0a
separator_length equ $ - separator
mmx_val_1 dw 1, 2, 3, 4
mmx_val_2 dw 1, 1, 1, 1
mmx_val_3 dw 1, 2, 3, 4
mmx_val_4 dw 2, 2, 2, 2
mmx_val_5 dw 1, 2, 3, 4
mmx_val_6 dw 0xff, 0xff, 0xff, 0xff
mmx_val_7 dw 1, 2, 3, 4
mmx_val_8 dw 0x4000, 0x4000, 0x4000, 0x4000
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
%macro perform_maddwd 2
emms ; inicializace MMX
mov ebx, %1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, %2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
pmaddwd mm1, mm2 ; soucin hodnot se souctem mezivysledku
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
print_string separator, separator_length
%endmacro
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
perform_maddwd mmx_val_1, mmx_val_2
perform_maddwd mmx_val_3, mmx_val_4
perform_maddwd mmx_val_5, mmx_val_6
perform_maddwd mmx_val_7, mmx_val_8
exit ; ukonceni procesu
%include "hex2string.asm"
17. Logické operace s 64bitovými vektory
Poslední čtyři instrukce, s nimiž se v dnešním článku setkáme, slouží pro výpočet logických operací stylem „bit po bitu“. Tyto instrukce pracují s celými 64bitovými vektory a vzhledem k tomu, že se výpočty provádí po jednotlivých bitech, není nutné rozlišovat typ vektorů (8 prvků, 4 prvky, 2 prvky atd.). Na rozdíl o podobných ALU instrukcí (ty jsou ovšem jen 32bitové) žádná z MMX instrukcí nenastavuje příznaky v příznakovém registru FLAGS. Na druhou stranu však mají programátoři k dispozici operaci AND-NOT, kterou lze využít například při zpracování rastrových obrázků atd.:
| # | Instrukce | Stručný popis instrukce |
|---|---|---|
| 1 | PAND | logická operace AND s 64bitovými hodnotami |
| 2 | POR | logická operace OR s 64bitovými hodnotami |
| 3 | PXOR | logická operace XOR s 64bitovými hodnotami |
| 4 | PANDN | logická operace AND NOT s 64bitovými hodnotami |
V dnešním posledním demonstračním příkladu budou tyto čtyři instrukce použity pro provedení logických operací mezi těmito dvěma vektory:
mmx_val_1 db 0, 1, 2, 3, 0, 1, 2, 3 mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
Následuje výpis zdrojového kódu tohoto příkladu:
[bits 32]
%include "linux_macros.asm"
;-----------------------------------------------------------------------------
section .data
hex_message:
times 8 db '?'
db ' '
hex_message_length equ $ - hex_message
pand_message:
db 0x0a, "pand:", 0x0a
pand_message_length equ $ - pand_message
por_message:
db 0x0a, "por:", 0x0a
por_message_length equ $ - por_message
pxor_message:
db 0x0a, "pxor:", 0x0a
pxor_message_length equ $ - pxor_message
pandn_message:
db 0x0a, "pandn:", 0x0a
pandn_message_length equ $ - pandn_message
mmx_val_1 db 0, 1, 2, 3, 0, 1, 2, 3
mmx_val_2 db 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
;-----------------------------------------------------------------------------
section .bss
mmx_tmp resb 8
;-----------------------------------------------------------------------------
section .text
global _start ; tento symbol ma byt dostupny i linkeru
_start:
emms ; inicializace MMX
mov ebx, mmx_val_1
movq mm1, [ebx] ; nacteni prvni hodnoty do registru MM1
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
mov ebx, mmx_val_2
movq mm2, [ebx] ; nacteni druhe hodnoty do registru MM1
print_mmx_reg_as_hex mm2 ; tisk hodnoty registru MM2
movq mm3, mm1 ; zapamatovat si hodnoty pro další použití
movq mm4, mm2
pand mm1, mm2 ; bitova operace AND
print_string pand_message, pand_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
por mm1, mm2 ; bitova operace OR
print_string por_message, por_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
pxor mm1, mm2 ; bitova operace XOR
print_string pxor_message, pxor_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
movq mm1, mm3 ; obnovit hodnoty vektoru
movq mm2, mm4
pandn mm1, mm2 ; bitova operace AND NOT
print_string pandn_message, pandn_message_length
print_mmx_reg_as_hex mm1 ; tisk hodnoty registru MM1
exit ; ukonceni procesu
%include "hex2string.asm"
Výsledky budou vypadat následovně (poznámky jsou opět dopsány ručně):
první vektor: 03020100 03020100
druhý vektor: 00000000 FFFFFFFF
-----------------
pand: 00000000 03020100
por: 03020100 FFFFFFFF
pxor: 03020100 FCFDFEFF
pandn: 00000000 FCFDFEFF
Poznámka: operace AND-NOT nejdříve provede AND všech příslušných bitů obou vektorů a posléze všech 64 bitů mezivýsledku zneguje. Používat se může pro maskování při vykreslování spritů atd.
18. Seznam popsaných instrukcí MMX
V rámci instrukční sady MMX bylo do instrukčního souboru mikroprocesorů řady 80×86 přidáno 56 či 57 nových instrukcí (konkrétní počet závisí na způsobu výpočtu). Prozatím jsme si popsali již 24 instrukcí a příště celý popis instrukční sady MMX dokončíme. Již popsané instrukce, z nichž většina byla použita v demonstračních příkladech, jsou uvedeny v této tabulce:
| # | Instrukce | Stručný popis instrukce |
|---|---|---|
| 1 | EMMS | inicializace subsystému MMX |
| 2 | MOVQ | přesun 64bitového vektoru z paměti do registru MMX či naopak |
| 3 | PADDB | součet dvou osmiprvkových vektorů, každý prvek má šířku osmi bitů |
| 4 | PADDW | součet dvou čtyřprvkových vektorů, každý prvek má šířku šestnácti bitů |
| 5 | PADDD | součet dvou dvouprvkových vektorů, každý prvek má šířku 32 bitů |
| 6 | PADDQ | součet dvou 64bitových celých čísel |
| 7 | PADDSB | součet dvou osmiprvkových vektorů se saturací, každý prvek má šířku osmi bitů se znaménkem |
| 8 | PADDUSB | součet dvou osmiprvkových vektorů se saturací, každý prvek má šířku osmi bitů bez znaménka |
| 9 | PADDSW | součet dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů se znaménkem |
| 10 | PADDUSW | součet dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů bez znaménka |
| 11 | PSUBB | rozdíl dvou osmiprvkových vektorů, každý prvek má šířku osmi bitů |
| 12 | PSUBW | rozdíl dvou čtyřprvkových vektorů, každý prvek má šířku šestnácti bitů |
| 13 | PSUBD | rozdíl dvou dvouprvkových vektorů, každý prvek má šířku 32 bitů |
| 14 | PSUBSB | rozdíl dvou osmiprvkových vektorů se saturací, každý prvek má šířku osmi bitů se znaménkem |
| 15 | PSUBUSB | rozdíl dvou osmiprvkových vektorů se saturací, každý prvek má šířku osmi bitů bez znaménka |
| 16 | PSUBSW | rozdíl dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů se znaménkem |
| 17 | PSUBUSW | rozdíl dvou čtyřprvkových vektorů se saturací, každý prvek má šířku šestnácti bitů bez znaménka |
| 18 | PMULLW | součin dvou čtyřprvkových vektorů, každý prvek má šířku šestnácti bitů, uloží se spodních 16 bitů výsledků |
| 19 | PMULHW | součin dvou čtyřprvkových vektorů, každý prvek má šířku šestnácti bitů, uloží se horních 16 bitů výsledků |
| 20 | PMADDWD | kombinace součinu prvků vektorů se součtem mezivýsledků |
| 21 | PAND | logická operace AND s 64bitovými hodnotami |
| 22 | POR | logická operace OR s 64bitovými hodnotami |
| 23 | PXOR | logická operace XOR s 64bitovými hodnotami |
| 24 | PANDN | logická operace AND NOT s 64bitovými hodnotami |
19. Repositář s demonstračními příklady
Demonstrační příklady napsané v assembleru, které jsou určené pro překlad s využitím assembleru NASM, byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/8bit-fame. Jednotlivé demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes již poměrně rozsáhlý) repositář:
| # | Příklad | Stručný popis | Adresa |
|---|---|---|---|
| 1 | hello.asm | program typu „Hello world“ naprogramovaný v assembleru pro systém DOS | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hello.asm |
| 2 | hello_shorter.asm | kratší varianta výskoku z procesu zpět do DOSu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hello_shorter.asm |
| 3 | hello_wait.asm | čekání na stisk klávesy | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hello_wait.asm |
| 4 | hello_macros.asm | realizace jednotlivých částí programu makrem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hello_macros.asm |
| 5 | gfx4_putpixel.asm | vykreslení pixelu v grafickém režimu 4 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_putpixel.asm |
| 6 | gfx6_putpixel.asm | vykreslení pixelu v grafickém režimu 6 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel.asm |
| 7 | gfx4_line.asm | vykreslení úsečky v grafickém režimu 4 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_line.asm |
| 8 | gfx6_line.asm | vykreslení úsečky v grafickém režimu 6 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_line.asm |
| 9 | gfx6_fill1.asm | vyplnění obrazovky v grafickém režimu, základní varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_fill1.asm |
| 10 | gfx6_fill2.asm | vyplnění obrazovky v grafickém režimu, varianta s instrukcí LOOP | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_fill2.asm |
| 11 | gfx6_fill3.asm | vyplnění obrazovky instrukcí REP STOSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_fill3.asm |
| 12 | gfx6_fill4.asm | vyplnění obrazovky, synchronizace vykreslování s paprskem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_fill4.asm |
| 13 | gfx4_image1.asm | vykreslení rastrového obrázku získaného z binárních dat, základní varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image1.asm |
| 14 | gfx4_image2.asm | varianta vykreslení rastrového obrázku s využitím instrukce REP MOVSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image2.asm |
| 15 | gfx4_image3.asm | varianta vykreslení rastrového obrázku s využitím instrukce REP MOVSW | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image3.asm |
| 16 | gfx4_image4.asm | korektní vykreslení všech sudých řádků bitmapy | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image4.asm |
| 17 | gfx4_image5.asm | korektní vykreslení všech sudých i lichých řádků bitmapy | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image5.asm |
| 18 | gfx4_image6.asm | nastavení barvové palety před vykreslením obrázku | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image6.asm |
| 19 | gfx4_image7.asm | nastavení barvové palety před vykreslením obrázku, snížená intenzita barev | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image7.asm |
| 20 | gfx4_image8.asm | postupná změna barvy pozadí | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx4_image8.asm |
| 21 | gfx6_putpixel1.asm | vykreslení pixelu, základní varianta se 16bitovým násobením | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel1.asm |
| 22 | gfx6_putpixel2.asm | vykreslení pixelu, varianta s osmibitovým násobením | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel2.asm |
| 23 | gfx6_putpixel3.asm | vykreslení pixelu, varianta bez násobení | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel3.asm |
| 24 | gfx6_putpixel4.asm | vykreslení pixelu přes obrázek, nekorektní chování (přepis obrázku) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel4.asm |
| 25 | gfx6_putpixel5.asm | vykreslení pixelu přes obrázek, korektní varianta pro bílé pixely | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/gfx6_putpixel5.asm |
| 26 | cga_text_mode1.asm | standardní textový režim s rozlišením 40×25 znaků | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_mode1.asm |
| 27 | cga_text_mode3.asm | standardní textový režim s rozlišením 80×25 znaků | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_mode3.asm |
| 28 | cga_text_mode_intensity.asm | změna významu nejvyššího bitu atributového bajtu: vyšší intenzita namísto blikání | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_mode_intensity.asm |
| 29 | cga_text_mode_cursor.asm | změna tvaru textového kurzoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_mode_cursor.asm |
| 30 | cga_text_gfx1.asm | zobrazení „rastrové mřížky“: pseudografický režim 160×25 pixelů (interně textový režim) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_gfx1.asm |
| 31 | cga_text_mode_char_height.asm | změna výšky znaků | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_mode_char_height.asm |
| 32 | cga_text_160×100.asm | grafický režim 160×100 se šestnácti barvami (interně upravený textový režim) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/cga_text_160×100.asm |
| 33 | hercules_text_mode1.asm | využití standardního textového režimu společně s kartou Hercules | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_text_mode1.asm |
| 34 | hercules_text_mode2.asm | zákaz blikání v textových režimech | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_text_mode2.asm |
| 35 | hercules_turn_off.asm | vypnutí generování video signálu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_turn_off.asm |
| 36 | hercules_gfx_mode1.asm | přepnutí karty Hercules do grafického režimu (základní varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_gfx_mode1.asm |
| 37 | hercules_gfx_mode2.asm | přepnutí karty Hercules do grafického režimu (vylepšená varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_gfx_mode2.asm |
| 38 | hercules_putpixel.asm | subrutina pro vykreslení jediného pixelu na kartě Hercules | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/hercules_putpixel.asm |
| 39 | ega_text_mode_80×25.asm | standardní textový režim 80×25 znaků na kartě EGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_text_mode_80×25.asm |
| 40 | ega_text_mode_80×43.asm | zobrazení 43 textových řádků na kartě EGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_text_mode_80×43.asm |
| 41 | ega_gfx_mode_320×200.asm | přepnutí do grafického režimu 320×200 pixelů se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_gfx_mode_320×200.asm |
| 42 | ega_gfx_mode_640×200.asm | přepnutí do grafického režimu 640×200 pixelů se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_gfx_mode_640×200.asm |
| 43 | ega_gfx_mode_640×350.asm | přepnutí do grafického režimu 640×350 pixelů se čtyřmi nebo šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_gfx_mode_640×350.asm |
| 44 | ega_gfx_mode_bitplanes1.asm | ovládání zápisu do bitových rovin v planárních grafických režimech (základní způsob) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_gfx_mode_bitplanes1.asm |
| 45 | ega_gfx_mode_bitplanes2.asm | ovládání zápisu do bitových rovin v planárních grafických režimech (rychlejší způsob) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_gfx_mode_bitplanes2.asm |
| 46 | ega_320×200_putpixel.asm | vykreslení pixelu v grafickém režimu 320×200 pixelů se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_320×200_putpixel.asm |
| 47 | ega_640×350_putpixel.asm | vykreslení pixelu v grafickém režimu 640×350 pixelů se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_640×350_putpixel.asm |
| 48 | ega_standard_font.asm | použití standardního fontu grafické karty EGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_standard_font.asm |
| 49 | ega_custom_font.asm | načtení vlastního fontu s jeho zobrazením | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_custom_font.asm |
| 50 | ega_palette1.asm | změna barvové palety (všech 16 barev) v grafickém režimu 320×200 se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_palette1.asm |
| 51 | ega_palette2.asm | změna barvové palety (všech 16 barev) v grafickém režimu 640×350 se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_palette2.asm |
| 52 | ega_palette3.asm | změna všech barev v barvové paletě s využitím programové smyčky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_palette3.asm |
| 53 | ega_palette4.asm | změna všech barev, včetně barvy okraje, v barvové paletě voláním funkce BIOSu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ega_palette4.asm |
| 54 | vga_text_mode_80×25.asm | standardní textový režim 80×25 znaků na kartě VGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_80×25.asm |
| 55 | vga_text_mode_80×50.asm | zobrazení 50 a taktéž 28 textových řádků na kartě VGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_80×50.asm |
| 56 | vga_text_mode_intensity1.asm | změna chování atributového bitu pro blikání (nebezpečná varianta změny registrů) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_intensity1.asm |
| 57 | vga_text_mode_intensity2.asm | změna chování atributového bitu pro blikání (bezpečnější varianta změny registrů) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_intensity2.asm |
| 58 | vga_text_mode_9th_column.asm | modifikace způsobu zobrazení devátého sloupce ve znakových režimech (720 pixelů na řádku) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_9th_column.asm |
| 59 | vga_text_mode_cursor_shape.asm | změna tvaru textového kurzoru na grafické kartě VGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_cursor_shape.asm |
| 60 | vga_text_mode_custom_font.asm | načtení vlastního fontu s jeho zobrazením | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_text_mode_custom_font.asm |
| 61 | vga_gfx_mode_640×480.asm | přepnutí do grafického režimu 640×480 pixelů se šestnácti barvami, vykreslení vzorků | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_640×480.asm |
| 62 | vga_gfx_mode_320×200.asm | přepnutí do grafického režimu 320×200 pixelů s 256 barvami, vykreslení vzorků | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_320×200.asm |
| 63 | vga_gfx_mode_palette.asm | změna všech barev v barvové paletě grafické karty VGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_palette.asm |
| 64 | vga_gfx_mode_dac1.asm | využití DAC (neočekávané výsledky) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_dac1.asm |
| 65 | vga_gfx_mode_dac2.asm | využití DAC (očekávané výsledky) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_dac2.asm |
| 66 | vga_640×480_putpixel.asm | realizace algoritmu pro vykreslení pixelu v grafickém režimu 640×480 pixelů se šestnácti barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_640×480_putpixel.asm |
| 67 | vga_320×200_putpixel1.asm | realizace algoritmu pro vykreslení pixelu v grafickém režimu 320×200 s 256 barvami (základní varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_putpixel1.asm |
| 68 | vga_320×200_putpixel2.asm | realizace algoritmu pro vykreslení pixelu v grafickém režimu 320×200 s 256 barvami (rychlejší varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_putpixel2.asm |
| 69 | vga_gfx_mode_dac3.asm | přímé využití DAC v grafickém režimu 13h | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_dac3.asm |
| 70 | vga_gfx_mode_unchained_step1.asm | zobrazení barevných pruhů v režimu 13h | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_unchained_step1.asm |
| 71 | vga_gfx_mode_unchained_step2.asm | vypnutí zřetězení bitových rovin a změna způsobu adresování pixelů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_unchained_step2.asm |
| 72 | vga_gfx_mode_unchained_step3.asm | vykreslení barevných pruhů do vybraných bitových rovin | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_unchained_step3.asm |
| 73 | vga_gfx_mode_320×400.asm | nestandardní grafický režim s rozlišením 320×400 pixelů a 256 barvami | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_gfx_mode_320×400.asm |
| 74 | vga_320×200_image.asm | zobrazení rastrového obrázku ve standardním grafickém režimu 320×200 pixelů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image.asm |
| 75 | vga_320×200_unchained_image1.asm | zobrazení rastrového obrázku v režimu s nezřetězenými rovinami (nekorektní řešení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_unchained_image1.asm |
| 76 | vga_320×200_unchained_image2.asm | zobrazení rastrového obrázku v režimu s nezřetězenými rovinami (korektní řešení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_unchained_image2.asm |
| 77 | vga_320×400_unchained_image.asm | zobrazení rastrového obrázku v nestandardním režimu 320×400 pixelů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×400_unchained_image.asm |
| 78 | vga_vertical_scroll1.asm | vertikální scrolling na kartě VGA v režimu s rozlišením 320×200 pixelů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_vertical_scroll1.asm |
| 79 | vga_vertical_scroll2.asm | vertikální scrolling na kartě VGA v režimu s rozlišením 320×400 pixelů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_vertical_scroll2.asm |
| 80 | vga_split_screen1.asm | režim split-screen a scrolling, nefunční varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_split_screen1.asm |
| 81 | vga_split_screen2.asm | režim split-screen a scrolling, plně funkční varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_split_screen2.asm |
| 82 | vga_horizontal_scroll1.asm | horizontální scrolling bez rozšíření počtu pixelů na virtuálním řádku | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_horizontal_scroll1.asm |
| 83 | vga_horizontal_scroll2.asm | horizontální scrolling s rozšířením počtu pixelů na virtuálním řádku | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_horizontal_scroll2.asm |
| 84 | vga_horizontal_scroll3.asm | jemný horizontální scrolling s rozšířením počtu pixelů na virtuálním řádku | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_horizontal_scroll3.asm |
| 85 | vga_320×240_image.asm | nastavení grafického režimu Mode-X, načtení a vykreslení obrázku, scrolling | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×240_image.asm |
| 86 | io.asm | knihovna maker pro I/O operace | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/io.asm |
| 87 | vga_lib.asm | knihovna maker a podprogramů pro programování karty VGA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_lib.asm |
| 88 | vga_320×240_lib.asm | nastavení grafického režimu Mode-X, tentokrát knihovními funkcemi | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×240_lib.asm |
| 89 | vga_bitblt1.asm | první (naivní) implementace operace BitBLT | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt1.asm |
| 90 | vga_bitblt2.asm | operace BitBLT s výběrem bitových rovin pro zápis | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt2.asm |
| 91 | vga_bitblt3.asm | operace BitBLT s výběrem bitových rovin pro čtení i zápis | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt3.asm |
| 92 | vga_bitblt4.asm | korektní BitBLT pro 16barevný režim, realizace makry | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt4.asm |
| 93 | vga_bitblt5.asm | korektní BitBLT pro 16barevný režim, realizace podprogramem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt5.asm |
| 94 | vga_bitblt_rotate.asm | zápisový režim s rotací bajtu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt_rotate.asm |
| 95 | vga_bitblt_fast.asm | rychlá korektní 32bitová operace typu BitBLT | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_bitblt_fast.asm |
| 96 | vga_320×400_bitblt1.asm | přenos obrázku v režimu 320×400 operací BitBLT (neúplná varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×400_bitblt1.asm |
| 97 | vga_320×400_bitblt2.asm | přenos obrázku v režimu 320×400 operací BitBLT (úplná varianta) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×400_bitblt2.asm |
| 98 | vga_write_modes1.asm | volitelné zápisové režimy grafické karty VGA, zápis bez úpravy latche | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_write_modes1.asm |
| 99 | vga_write_modes2.asm | volitelné zápisové režimy grafické karty VGA, zápis s modifikací latche | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_write_modes2.asm |
| 100 | vga_write_modes3.asm | volitelné zápisové režimy grafické karty VGA, cílená modifikace latche vzorkem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_write_modes3.asm |
| 101 | instruction_jump.asm | použití instrukce JMP | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_jump.asm |
| 102 | instruction_jnz.asm | použití instrukce JNZ pro realizaci programové smyčky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_jnz.asm |
| 103 | instruction_jz_jmp.asm | použití instrukcí JZ a JMP pro realizaci programové smyčky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_jz_jmp.asm |
| 104 | instruction_loop.asm | použití instrukce LOOP pro realizaci programové smyčky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_loop.asm |
| 105 | instruction_template.asm | šablona všech následujících demonstračních příkladů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_template.asm |
| 106 | instruction_print_hex.asm | tisk osmibitové hexadecimální hodnoty | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_print_hex.asm |
| 107 | instruction_xlat.asm | využití instrukce XLAT pro získání tisknutelné hexadecimální cifry | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_xlat.asm |
| 108 | instruction_daa.asm | operace součtu s využitím binární i BCD aritmetiky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_daa.asm |
| 109 | instruction_daa_sub.asm | instrukce DAA po provedení operace rozdílu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_daa_sub.asm |
| 110 | instruction_das.asm | instrukce DAS po provedení operace rozdílu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_das.asm |
| 111 | instruction_aaa.asm | korekce výsledku na jedinou BCD cifru operací AAA | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_aaa.asm |
| 112 | instruction_mul.asm | ukázka výpočtu součinu dvou osmibitových hodnot | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_mul.asm |
| 113 | instruction_aam.asm | BCD korekce po výpočtu součinu instrukcí AAM | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_aam.asm |
| 114 | instruction_stosb.asm | blokový zápis dat instrukcí STOSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_stosb.asm |
| 115 | instruction_rep_stosb.asm | opakované provádění instrukce STOSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_rep_stosb.asm |
| 116 | instruction_lodsb.asm | čtení dat instrukcí LODSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_lodsb.asm |
| 117 | instruction_movsb.asm | přenos jednoho bajtu instrukcí MOVSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_movsb.asm |
| 118 | instruction_rep_movsb.asm | blokový přenos po bajtech instrukcí MOVSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_rep_movsb.asm |
| 119 | instruction_rep_scas.asm | vyhledávání v řetězci instrukcí SCAS | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_rep_scas.asm |
| 120 | vga_320×200_image_0B.asm | výsledek blokového přenosu ve chvíli, kdy je CX=0 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_0B.asm |
| 121 | vga_320×200_image_64kB.asm | výsledek blokového přenosu ve chvíli, kdy je CX=0×ffff | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_64kB.asm |
| 122 | vga_320×200_image_movsb.asm | blokový přenos v rámci obrazové paměti instrukcí REP MOVSB | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsb.asm |
| 123 | vga_320×200_image_movsw.asm | blokový přenos v rámci obrazové paměti instrukcí REP MOVSW | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsw.asm |
| 124 | vga_320×200_image_movsd.asm | blokový přenos v rámci obrazové paměti instrukcí REP MOVSD | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsd.asm |
| 125 | vga_320×200_image_movsb_forward.asm | blokový přenos překrývajících se bloků paměti (zvyšující se adresy) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsb_forward.asm |
| 126 | vga_320×200_image_movsb_backward1.asm | blokový přenos překrývajících se bloků paměti (snižující se adresy, nekorektní nastavení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsb_backward1.asm |
| 127 | vga_320×200_image_movsb_backward2.asm | blokový přenos překrývajících se bloků paměti (snižující se adresy, korektní nastavení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_image_movsb_backward2.asm |
| 128 | sound_bell.asm | přehrání zvuku pomocí tisku ASCII znaku BELL | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_bell.asm |
| 129 | sound_beep.asm | přehrání zvuku o zadané frekvenci na PC Speakeru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_beep.asm |
| 130 | sound_play_pitch.asm | přehrání zvuku o zadané frekvenci na PC Speakeru, použití maker | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_play_pitch.asm |
| 131 | sound_opl2_basic.asm | přehrání komorního A na OPL2 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl2_basic.asm |
| 132 | sound_opl2_table.asm | přehrání komorního A na OPL2, použití tabulky s hodnotami registrů | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl2_table.asm |
| 133 | sound_opl2_table2.asm | přepis tabulky s obsahy registrů pro přehrání komorního A | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl2_table2.asm |
| 134 | sound_key_on.asm | přímé ovládání bitu KEY ON mezerníkem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_key_on.asm |
| 135 | sound_adsr.asm | nastavení obálky pro tón přehrávaný prvním kanálem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_adsr.asm |
| 136 | sound_modulation.asm | řízení frekvence modulátoru klávesami 1 a 0 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_modulation.asm |
| 137 | keyboard_basic.asm | přímá práce s klávesnicí IBM PC | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/keyboard_basic.asm |
| 138 | sound_stereo_opl2.asm | stereo zvuk v konfiguraci DualOPL2 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_stereo_opl2.asm |
| 139 | sound_opl2_multichannel.asm | vícekanálový zvuk na OPL2 (klávesy), delší varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl2_multichannel.asm |
| 140 | sound_opl2_multichannel2.asm | vícekanálový zvuk na OPL2 (klávesy), kratší varianta | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl2_multichannel2.asm |
| 141 | sound_opl3_stereo1.asm | stereo výstup na OPL3 (v kompatibilním režimu) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_stereo1.asm |
| 142 | sound_opl3_stereo2.asm | stereo výstup na OPL3 (v režimu OPL3) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_stereo2.asm |
| 143 | sound_opl3_multichannel.asm | vícekanálový zvuk na OPL3 (klávesy) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_multichannel.asm |
| 144 | sound_opl3_waveform1.asm | interaktivní modifikace tvaru vlny u prvního operátoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_waveform1.asm |
| 145 | sound_opl3_waveform2.asm | oprava chyby: povolení režimu kompatibilního s OPL3 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_waveform2.asm |
| 146 | sound_opl3_waveform3.asm | vliv tvaru vln na zvukový kanál s FM syntézou | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_waveform3.asm |
| 147 | sound_opl3_waveform4.asm | modifikace tvaru vlny nosné vlny i modulátoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_waveform4.asm |
| 148 | sound_opl3_4operators1.asm | výběr AM/FM režimu ve čtyřoperátorovém nastavení | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_4operators1.asm |
| 149 | sound_opl3_4operators2.asm | výběr AM/FM režimu ve čtyřoperátorovém nastavení | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/sound_opl3_4operators2.asm |
| 150 | timer_basic.asm | základní obsluha přerušení od časovače/čítače | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/timer_basic.asm |
| 151 | timer_restore.asm | obnovení původní obsluhy přerušení při ukončování aplikace | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/timer_restore.asm |
| 152 | timer_restore_better_structure.asm | refaktoring předchozího demonstračního příkladu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/timer_restore_better_structure.asm |
| 153 | timer_faster_clock.asm | zrychlení čítače na 100 přerušení za sekundu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/timer_faster_clock.asm |
| 154 | instruction_push_imm.asm | instrukce PUSH s konstantou | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_push_imm.asm |
| 155 | instruction_imul_imm.asm | instrukce IMUL s konstantou | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_imul_imm.asm |
| 156 | instruction_into1.asm | instrukce INTO s obsluhou přerušení | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_into1.asm |
| 157 | instruction_into2.asm | instrukce INTO s obsluhou přerušení | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_into2.asm |
| 158 | instruction_bound1.asm | instrukce BOUND s obsluhou přerušení (nekorektní řešení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_bound1.asm |
| 159 | instruction_bound2.asm | instrukce BOUND s obsluhou přerušení (korektní řešení) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_bound2.asm |
| 160 | vga_320×200_putpixel286.asm | instrukce bitového posunu s konstantou větší než 1 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_putpixel286.asm |
| 161 | instruction_push_pop.asm | instrukce PUSH a POP se všemi pracovními registry | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_push_pop.asm |
| 162 | instruction_push_pop_B.asm | instrukce s novými segmentovými registry | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_push_pop_B.asm |
| 163 | instruction_near_jz_jmp.asm | blízké skoky | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_near_jz_jmp.asm |
| 164 | instruction_bsf.asm | nová instrukce BSF | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_bsf.asm |
| 165 | instruction_bsr.asm | nová instrukce BSR | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_bsr.asm |
| 166 | instruction_add_32bit.asm | 32bitový součet | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_add_32bit.asm |
| 167 | instruction_inc_32bit.asm | 32bitová instrukce INC v šestnáctibitovém režimu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_inc_32bit.asm |
| 168 | instruction_inc_32bit_B.asm | 32bitová instrukce INC v 32bitovém režimu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/instruction_inc_32bit_B.asm |
| 169 | ems_status.asm | zjištění stavu (emulace) paměti EMS | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ems_status.asm |
| 170 | ems_total_mem.asm | získání celkové kapacity paměti EMS v blocích | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ems_total_mem.asm |
| 171 | ems_free_mem.asm | získání volné kapacity paměti EMS v blocích | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/ems_free_mem.asm |
| 172 | xms_free_mem.asm | získání volné kapacity paměti XMS v blocích | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/xms_free_mem.asm |
| 173 | vga_320×200_short_address1.asm | blokový přenos provedený v rámci prostoru segmentu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_short_address1.asm |
| 174 | vga_320×200_short_address2.asm | rozepsaný blokový přenos provedený v rámci prostoru segmentu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_short_address2.asm |
| 175 | vga_320×200_short_address3.asm | přenos nelze provést přes hranici offsetu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_short_address3.asm |
| 176 | vga_320×200_short_address4.asm | přenos nelze provést přes hranici offsetu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_short_address4.asm |
| 177 | vga_320×200_long_address1.asm | 32bitový blokový přenos | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_long_address1.asm |
| 178 | vga_320×200_long_address2.asm | rozepsaný 32bitový blokový přenos provedený v rámci prostoru segmentu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_long_address2.asm |
| 179 | vga_320×200_long_address3.asm | přístup do obrazové paměti přes segment 0×0000 a 32bitový offset | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_long_address3.asm |
| 180 | vga_320×200_long_address4.asm | otestování, jak lze přenášet data s využitím 32bitového offsetu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/vga_320×200_long_address4.asm |
| 181 | print_msw.asm | přečtení a zobrazení obsahu speciálního registru MSW | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/print_msw.asm |
| 182 | print_cr0.asm | přečtení a zobrazení obsahu speciálního registru CR0 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/print_cr0.asm |
| 183 | prot_mode286.asm | přechod do chráněného režimu na čipech Intel 80286 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/prot_mode286.asm |
| 184 | prot_mode386.asm | přechod do chráněného režimu na čipech Intel 80386 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/prot_mode386.asm |
| 185 | prot_mode_back_to_real_mode286.asm | přechod mezi reálným režimem a chráněným režimem i zpět na čipech Intel 80286 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/prot_mode_back_to_real_mode286.asm |
| 186 | prot_mode_back_to_real_mode386.asm | přechod mezi reálným režimem a chráněným režimem i zpět na čipech Intel 80386 | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/prot_mode_back_to_real_mode386.asm |
| 187 | prot_mode_check.asm | test, zda se mikroprocesor již nachází v chráněném režimu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/prot_mode_check.asm |
| 188 | unreal_mode.asm | nastavení nereálného režimu (platné pro Intel 80386) | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/unreal_mode.asm |
| 189 | float32_constants.asm | vytištění základních FP konstant typu single | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/float32_constants.asm |
| 190 | float64_constants.asm | vytištění základních FP konstant typu double | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/float64_constants.asm |
| 191 | fpu_arithmetic.asm | základní aritmetické operace prováděné matematickým koprocesorem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_arithmetic.asm |
| 192 | fpu_divide_by_zero.asm | dělení nulou matematickým koprocesorem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide_by_zero.asm |
| 193 | fpu_divide_by_neg_zero.asm | dělení záporné hodnoty nulou matematickým koprocesorem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide_by_neg_zero.asm |
| 194 | fpu_divide_by_neg_zero2.asm | dělení hodnoty zápornou nulou matematickým koprocesorem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide_by_neg_zero2.asm |
| 195 | fpu_divide_zero_by_zero.asm | výpočet 0/0 matematickým koprocesorem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide_zero_by_zero.asm |
| 196 | io.asm | pomocná makra pro komunikaci s DOSem a BIOSem | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/io.asm |
| 197 | print.asm | pomocná makra pro tisk FPU hodnot typu single a double v hexadecimálním tvaru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/print.asm |
| 198 | fpu_divide.asm | operace podílu | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide.asm |
| 199 | fpu_divide_r.asm | operace podílu s prohozenými operandy | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_divide_r.asm |
| 200 | fpu_sqrt.asm | výpočet druhé odmocniny | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_sqrt.asm |
| 201 | fpu_sqrt_neg_value.asm | výpočet druhé odmocniny ze záporné hodnoty | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_sqrt_neg_value.asm |
| 202 | fpu_check.asm | detekce typu matematického koprocesoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_check.asm |
| 203 | fpu_compare.asm | porovnání dvou hodnot s vyhodnocením výsledku | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_compare.asm |
| 204 | fpu_status_word.asm | tisk obsahu stavového slova koprocesoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_status_word.asm |
| 205 | fpu_status_word_stack.asm | tisk obsahu stavového slova koprocesoru | https://github.com/tisnik/8bit-fame/blob/master/pc-dos/fpu_status_word_stack.asm |
| 206 | Makefile | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/Makefile | |
| 207 | hex2string.asm | subrutina pro převod 32bitové hexadecimální hodnoty na řetězec | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/hex2string.asm |
| 208 | linux_macros.asm | pomocná makra pro tvorbu aplikací psaných v assembleru pro Linux | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/linux_macros.asm |
| 209 | mmx_init.asm | inicializace subsystému MMX | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_init.asm |
| 210 | mmx_paddb1.asm | zavolání MMX instrukce pro součet vektorů bajtů (bez přetečení) | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddb1.asm |
| 211 | mmx_paddb2.asm | zavolání MMX instrukce pro součet vektorů bajtů (s přetečením) | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddb2.asm |
| 212 | mmx_paddusb.asm | zavolání MMX instrukce pro součet vektorů bajtů se saturací | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddusb.asm |
| 213 | mmx_paddw.asm | zavolání MMX instrukce pro součet vektorů šestnáctibitových slov | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddw.asm |
| 214 | mmx_paddd.asm | zavolání MMX instrukce pro součet vektorů 32bitových slov | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddd.asm |
| 215 | mmx_paddq.asm | zavolání MMX instrukce pro součet 64bitových slov | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddq.asm |
| 216 | mmx_paddx.asm | porovnání operací součtu pro vektory s prvky různých typů | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddx.asm |
| 217 | mmx_support.asm | zjištění, zda je MMX podporována | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_support.asm |
| 218 | mmx_paddx_saturation.asm | součet osmiprvkových a čtyřprvkových vektorů se saturací | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_paddx_saturation.asm |
| 219 | mmx_psubx.asm | rozdíl vektorů s různým počtem a šířkou prvků | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_psubx.asm |
| 220 | mmx_pmullw1.asm | součin vektorů prvek po prvku se získáním spodních 16 bitů výsledků (varianta bez přetečení) | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_pmullw1.asm |
| 221 | mmx_pmullw2.asm | součin vektorů prvek po prvku se získáním spodních 16 bitů výsledků (varianta s přetečením) | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_pmullw2.asm |
| 222 | mmx_pmulhw.asm | součin vektorů prvek po prvku se získáním horních 16 bitů výsledků (varianta s přetečením) | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_pmulhw.asm |
| 223 | mmx_pmaddwd.asm | součin vektorů prvek po prvku, součet mezivýsledků | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_pmaddwd.asm |
| 224 | mmx_logical.asm | logické instrukce MMX | https://github.com/tisnik/8bit-fame/blob/master/pc-linux/mmx_logical.asm |
20. Odkazy na Internetu
- The Intel 8088 Architecture and Instruction Set
https://people.ece.ubc.ca/~edc/464/lectures/lec4.pdf - x86 Opcode Structure and Instruction Overview
https://pnx.tf/files/x86_opcode_structure_and_instruction_overview.pdf - x86 instruction listings (Wikipedia)
https://en.wikipedia.org/wiki/X86_instruction_listings - x86 assembly language (Wikipedia)
https://en.wikipedia.org/wiki/X86_assembly_language - Intel Assembler (Cheat sheet)
http://www.jegerlehner.ch/intel/IntelCodeTable.pdf - 25 Microchips That Shook the World
https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world - Chip Hall of Fame: MOS Technology 6502 Microprocessor
https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor - Chip Hall of Fame: Intel 8088 Microprocessor
https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-intel-8088-microprocessor - Jak se zrodil procesor?
https://www.root.cz/clanky/jak-se-zrodil-procesor/ - Apple II History Home
http://apple2history.org/ - The 8086/8088 Primer
https://www.stevemorse.org/8086/index.html - flat assembler: Assembly language resources
https://flatassembler.net/ - FASM na Wikipedii
https://en.wikipedia.org/wiki/FASM - Fresh IDE FASM inside
https://fresh.flatassembler.net/ - MS-DOS Version 4.0 Programmer's Reference
https://www.pcjs.org/documents/books/mspl13/msdos/dosref40/ - DOS API (Wikipedia)
https://en.wikipedia.org/wiki/DOS_API - Bit banging
https://en.wikipedia.org/wiki/Bit_banging - IBM Basic assembly language and successors (Wikipedia)
https://en.wikipedia.org/wiki/IBM_Basic_assembly_language_and_successors - X86 Assembly/Bootloaders
https://en.wikibooks.org/wiki/X86_Assembly/Bootloaders - Počátky grafiky na PC: grafické karty CGA a Hercules
https://www.root.cz/clanky/pocatky-grafiky-na-pc-graficke-karty-cga-a-hercules/ - Co mají společného Commodore PET/4000, BBC Micro, Amstrad CPC i grafické karty MDA, CGA a Hercules?
https://www.root.cz/clanky/co-maji-spolecneho-commodore-pet-4000-bbc-micro-amstrad-cpc-i-graficke-karty-mda-cga-a-hercules/ - Karta EGA: první použitelná barevná grafika na PC
https://www.root.cz/clanky/karta-ega-prvni-pouzitelna-barevna-grafika-na-pc/ - RGB Classic Games
https://www.classicdosgames.com/ - Turbo Assembler (Wikipedia)
https://en.wikipedia.org/wiki/Turbo_Assembler - Microsoft Macro Assembler
https://en.wikipedia.org/wiki/Microsoft_Macro_Assembler - IBM Personal Computer (Wikipedia)
https://en.wikipedia.org/wiki/IBM_Personal_Computer - Intel 8251
https://en.wikipedia.org/wiki/Intel_8251 - Intel 8253
https://en.wikipedia.org/wiki/Intel_8253 - Intel 8255
https://en.wikipedia.org/wiki/Intel_8255 - Intel 8257
https://en.wikipedia.org/wiki/Intel_8257 - Intel 8259
https://en.wikipedia.org/wiki/Intel_8259 - Support/peripheral/other chips – 6800 family
http://www.cpu-world.com/Support/6800.html - Motorola 6845
http://en.wikipedia.org/wiki/Motorola_6845 - The 6845 Cathode Ray Tube Controller (CRTC)
http://www.tinyvga.com/6845 - CRTC operation
http://www.6502.org/users/andre/hwinfo/crtc/crtc.html - The 6845 Cathode Ray Tube Controller (CRTC)
http://www.tinyvga.com/6845 - Motorola 6845 and bitwise graphics
https://retrocomputing.stackexchange.com/questions/10996/motorola-6845-and-bitwise-graphics - IBM Monochrome Display Adapter
http://en.wikipedia.org/wiki/Monochrome_Display_Adapter - Color Graphics Adapter
http://en.wikipedia.org/wiki/Color_Graphics_Adapter - Color Graphics Adapter and the Brown color in IBM 5153 Color Display
https://www.aceinnova.com/en/electronics/cga-and-the-brown-color-in-ibm-5153-color-display/ - The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller
https://hackaday.com/2017/05/14/the-modern-retrocomputer-an-arduino-driven-6845-crt-controller/ - flat assembler: Assembly language resources
https://flatassembler.net/ - FASM na Wikipedii
https://en.wikipedia.org/wiki/FASM - Fresh IDE FASM inside
https://fresh.flatassembler.net/ - MS-DOS Version 4.0 Programmer's Reference
https://www.pcjs.org/documents/books/mspl13/msdos/dosref40/ - DOS API (Wikipedia)
https://en.wikipedia.org/wiki/DOS_API - IBM Basic assembly language and successors (Wikipedia)
https://en.wikipedia.org/wiki/IBM_Basic_assembly_language_and_successors - X86 Assembly/Arithmetic
https://en.wikibooks.org/wiki/X86_Assembly/Arithmetic - Art of Assembly – Arithmetic Instructions
http://oopweb.com/Assembly/Documents/ArtOfAssembly/Volume/Chapter6/CH06–2.html - ASM Flags
http://www.cavestory.org/guides/csasm/guide/asm_flags.html - Status Register
https://en.wikipedia.org/wiki/Status_register - Linux assemblers: A comparison of GAS and NASM
http://www.ibm.com/developerworks/library/l-gas-nasm/index.html - Programovani v assembleru na OS Linux
http://www.cs.vsb.cz/grygarek/asm/asmlinux.html - Is it worthwhile to learn x86 assembly language today?
https://www.quora.com/Is-it-worthwhile-to-learn-x86-assembly-language-today?share=1 - Why Learn Assembly Language?
http://www.codeproject.com/Articles/89460/Why-Learn-Assembly-Language - Is Assembly still relevant?
http://programmers.stackexchange.com/questions/95836/is-assembly-still-relevant - Why Learning Assembly Language Is Still a Good Idea
http://www.onlamp.com/pub/a/onlamp/2004/05/06/writegreatcode.html - Assembly language today
http://beust.com/weblog/2004/06/23/assembly-language-today/ - Assembler: Význam assembleru dnes
http://www.builder.cz/rubriky/assembler/vyznam-assembleru-dnes-155960cz - Programming from the Ground Up Book – Summary
http://savannah.nongnu.org/projects/pgubook/ - DOSBox
https://www.dosbox.com/ - The C Programming Language
https://en.wikipedia.org/wiki/The_C_Programming_Language - Hercules Graphics Card (HCG)
https://en.wikipedia.org/wiki/Hercules_Graphics_Card - Complete 8086 instruction set
https://content.ctcd.edu/courses/cosc2325/m22/docs/emu8086ins.pdf - Complete 8086 instruction set
https://yassinebridi.github.io/asm-docs/8086_instruction_set.html - 8088 MPH by Hornet + CRTC + DESiRE (final version)
https://www.youtube.com/watch?v=hNRO7lno_DM - Area 5150 by CRTC & Hornet (Party Version) / IBM PC+CGA Demo, Hardware Capture
https://www.youtube.com/watch?v=fWDxdoRTZPc - 80×86 Integer Instruction Set Timings (8088 – Pentium)
http://aturing.umcs.maine.edu/~meadow/courses/cos335/80×86-Integer-Instruction-Set-Clocks.pdf - Colour Graphics Adapter: Notes
https://www.seasip.info/VintagePC/cga.html - Restoring A Vintage CGA Card With Homebrew HASL
https://hackaday.com/2024/06/12/restoring-a-vintage-cga-card-with-homebrew-hasl/ - Demoing An 8088
https://hackaday.com/2015/04/10/demoing-an-8088/ - Video Memory Layouts
http://www.techhelpmanual.com/89-video_memory_layouts.html - Screen Attributes
http://www.techhelpmanual.com/87-screen_attributes.html - IBM PC Family – BIOS Video Modes
https://www.minuszerodegrees.net/video/bios_video_modes.htm - EGA Functions
https://cosmodoc.org/topics/ega-functions/#the-hierarchy-of-the-ega - Why the EGA can only use 16 of its 64 colours in 200-line modes
https://www.reenigne.org/blog/why-the-ega-can-only-use-16-of-its-64-colours-in-200-line-modes/ - How 16 colors saved PC gaming – the story of EGA graphics
https://www.custompc.com/retro-tech/ega-graphics - List of 16-bit computer color palettes
https://en.wikipedia.org/wiki/List_of16-bit_computer_color_palettes - Why were those colors chosen to be the default palette for 256-color VGA?
https://retrocomputing.stackexchange.com/questions/27994/why-were-those-colors-chosen-to-be-the-default-palette-for-256-color-vga - VGA Color Palettes
https://www.fountainware.com/EXPL/vga_color_palettes.htm - Hardware Level VGA and SVGA Video Programming Information Page
http://www.osdever.net/FreeVGA/vga/vga.htm - Hardware Level VGA and SVGA Video Programming Information Page – sequencer
http://www.osdever.net/FreeVGA/vga/seqreg.htm - VGA Basics
http://www.brackeen.com/vga/basics.html - Introduction to VGA Mode ‚X‘
https://web.archive.org/web/20160414072210/http://fly.srk.fer.hr/GDM/articles/vgamodex/vgamx1.html - VGA Mode-X
https://web.archive.org/web/20070123192523/http://www.gamedev.net/reference/articles/article356.asp - Mode-X: 256-Color VGA Magic
https://downloads.gamedev.net/pdf/gpbb/gpbb47.pdf - Instruction Format in 8086 Microprocessor
https://www.includehelp.com/embedded-system/instruction-format-in-8086-microprocessor.aspx - How to use „AND,“ „OR,“ and „XOR“ modes for VGA Drawing
https://retrocomputing.stackexchange.com/questions/21936/how-to-use-and-or-and-xor-modes-for-vga-drawing - VGA Hardware
https://wiki.osdev.org/VGA_Hardware - Programmer's Guide to Yamaha YMF 262/OPL3 FM Music Synthesizer
https://moddingwiki.shikadi.net/wiki/OPL_chip - Does anybody understand how OPL2 percussion mode works?
https://forum.vcfed.org/index.php?threads/does-anybody-understand-how-opl2-percussion-mode-works.60925/ - Yamaha YMF262 OPL3 music – MoonDriver for OPL3 DEMO [Oscilloscope View]
https://www.youtube.com/watch?v=a7I-QmrkAak - Yamaha OPL vs OPL2 vs OPL3 comparison
https://www.youtube.com/watch?v=5knetge5Gs0 - OPL3 Music Crockett's Theme
https://www.youtube.com/watch?v=HXS008pkgSQ - Bad Apple (Adlib Tracker – OPL3)
https://www.youtube.com/watch?v=2lEPH6Y3Luo - FM Synthesis Chips, Codecs and DACs
https://www.dosdays.co.uk/topics/fm_synthesizers.php - The Zen Challenge – YMF262 OPL3 Original (For an upcoming game)
https://www.youtube.com/watch?v=6JlFIFz1CFY - [adlib tracker II techno music – opl3] orbit around alpha andromedae I
https://www.youtube.com/watch?v=YqxJCu_WFuA - [adlib tracker 2 music – opl3 techno] hybridisation process on procyon-ii
https://www.youtube.com/watch?v=daSV5mN0sJ4 - Hyper Duel – Black Rain (YMF262 OPL3 Cover)
https://www.youtube.com/watch?v=pu_mzRRq8Ho - IBM 5155–5160 Technical Reference
https://www.minuszerodegrees.net/manuals/IBM/IBM_5155_5160_Technical_Reference_6280089_MAR86.pdf - a ymf262/opl3+pc speaker thing i made
https://www.youtube.com/watch?v=E-Mx0lEmnZ0 - [OPL3] Like a Thunder
https://www.youtube.com/watch?v=MHf06AGr8SU - (PC SPEAKER) bad apple
https://www.youtube.com/watch?v=LezmKIIHyUg - Powering devices from PC parallel port
http://www.epanorama.net/circuits/lptpower.html - Magic Mushroom (demo pro PC s DOSem)
http://www.crossfire-designs.de/download/articles/soundcards//mushroom.rar - Píseň Magic Mushroom – originál
http://www.crossfire-designs.de/download/articles/soundcards/speaker_mushroom_converted.mp3 - Píseň Magic Mushroom – hráno na PC Speakeru
http://www.crossfire-designs.de/download/articles/soundcards/speaker_mushroom_speaker.mp3 - Pulse Width Modulation (PWM) Simulation Example
http://decibel.ni.com/content/docs/DOC-4599 - Resistor/Pulse Width Modulation DAC
http://www.k9spud.com/traxmod/pwmdac.php - Class D Amplifier
http://en.wikipedia.org/wiki/Electronic_amplifier#Class_D - Covox Speech Thing / Disney Sound Source (1986)
http://www.crossfire-designs.de/index.php?lang=en&what=articles&name=showarticle.htm&article=soundcards/&page=5 - Covox Digital-Analog Converter (Rusky, obsahuje schémata)
http://phantom.sannata.ru/konkurs/netskater002.shtml - PC-GPE on the Web
http://bespin.org/~qz/pc-gpe/ - Keyboard Synthesizer
http://www.solarnavigator.net/music/instruments/keyboards.htm - FMS – Fully Modular Synthesizer
http://fmsynth.sourceforge.net/ - Javasynth
http://javasynth.sourceforge.net/ - Software Sound Synthesis & Music Composition Packages
http://www.linux-sound.org/swss.html - Mx44.1 Download Page (software synthesizer for linux)
http://hem.passagen.se/ja_linux/ - Software synthesizer
http://en.wikipedia.org/wiki/Software_synthesizer - Frequency modulation synthesis
http://en.wikipedia.org/wiki/Frequency_modulation_synthesis - Yamaha DX7
http://en.wikipedia.org/wiki/Yamaha_DX7 - Wave of the Future
http://www.wired.com/wired/archive/2.03/waveguides_pr.html - Analog synthesizer
http://en.wikipedia.org/wiki/Analog_synthesizer - Minimoog
http://en.wikipedia.org/wiki/Minimoog - Moog synthesizer
http://en.wikipedia.org/wiki/Moog_synthesizer - Tutorial for Frequency Modulation Synthesis
http://www.sfu.ca/~truax/fmtut.html - An Introduction To FM
http://ccrma.stanford.edu/software/snd/snd/fm.html - John Chowning
http://en.wikipedia.org/wiki/John_Chowning - I'm Impressed, Adlib Music is AMAZING!
https://www.youtube.com/watch?v=PJNjQYp1ras - Milinda- Diode Milliampere ( OPL3 )
https://www.youtube.com/watch?v=oNhazT5HG0E - Dune 2 – Roland MT-32 Soundtrack
https://www.youtube.com/watch?v=kQADZeB-z8M - Interrupts
https://wiki.osdev.org/Interrupts#Types_of_Interrupts - Assembly8086SoundBlasterDmaSingleCycleMode
https://github.com/leonardo-ono/Assembly8086SoundBlasterDmaSingleCycleMode/blob/master/sbsc.asm - Interrupts in 8086 microprocessor
https://www.geeksforgeeks.org/interrupts-in-8086-microprocessor/ - Interrupt Structure of 8086
https://www.eeeguide.com/interrupt-structure-of-8086/ - A20 line
https://en.wikipedia.org/wiki/A20_line - Extended memory
https://en.wikipedia.org/wiki/Extended_memory#eXtended_Memory_Specification_(XMS) - Expanded memory
https://en.wikipedia.org/wiki/Expanded_memory - Protected mode
https://en.wikipedia.org/wiki/Protected_mode - Virtual 8086 mode
https://en.wikipedia.org/wiki/Virtual_8086_mode - Unreal mode
https://en.wikipedia.org/wiki/Unreal_mode - DOS memory management
https://en.wikipedia.org/wiki/DOS_memory_management - Upper memory area
https://en.wikipedia.org/wiki/Upper_memory_area - Removing the Mystery from SEGMENT : OFFSET Addressing
https://thestarman.pcministry.com/asm/debug/Segments.html - Segment descriptor
https://en.wikipedia.org/wiki/Segment_descriptor - When using a 32-bit register to address memory in the real mode, contents of the register must never exceed 0000FFFFH. Why?
https://stackoverflow.com/questions/45094696/when-using-a-32-bit-register-to-address-memory-in-the-real-mode-contents-of-the - A Brief History of Unreal Mode
https://www.os2museum.com/wp/a-brief-history-of-unreal-mode/ - Segment Limits
https://wiki.osdev.org/Segment_Limits - How do 32 bit addresses in real mode work?
https://forum.osdev.org/viewtopic.php?t=30642 - The LOADALL Instruction by Robert Collins
https://www.rcollins.org/articles/loadall/tspec_a3_doc.html - How do you put a 286 in Protected Mode?
https://retrocomputing.stackexchange.com/questions/7683/how-do-you-put-a-286-in-protected-mode - Control register
https://en.wikipedia.org/wiki/Control_register - CPU Registers x86
https://wiki.osdev.org/CPU_Registers_x86 - x86 Assembly/Protected Mode
https://en.wikibooks.org/wiki/X86_Assembly/Protected_Mode - MSW: Machine Status Word
https://web.itu.edu.tr/kesgin/mul06/intel/intel_msw.html - 80×87 Floating Point Opcodes
http://www.techhelpmanual.com/876–80×87_floating_point_opcodes.html - Page Translation
https://pdos.csail.mit.edu/6.828/2005/readings/i386/s05_02.htm - 80386 Paging and Segmenation
https://stackoverflow.com/questions/38229741/80386-paging-and-segmenation - 80386 Memory Management
https://tldp.org/LDP/khg/HyperNews/get/memory/80386mm.html - DOSEMU
http://www.dosemu.org/ - Intel 80386, a revolutionary CPU
https://www.xtof.info/intel80386.html - PAI Unit 3 Paging in 80386 Microporcessor
https://www.slideshare.net/KanchanPatil34/pai-unit-3-paging-in-80386-microporcessor - 64 Terabytes of virtual memory for 32-bit x86 using segmentation: how?
https://stackoverflow.com/questions/5444984/64-terabytes-of-virtual-memory-for-32-bit-x86-using-segmentation-how - Pi in the Pentium: reverse-engineering the constants in its floating-point unit
http://www.righto.com/2025/01/pentium-floating-point-ROM.html - Simply FPU
http://www.website.masmforum.com/tutorials/fptute/ - Art of Assembly language programming: The 80×87 Floating Point Coprocessors
https://courses.engr.illinois.edu/ece390/books/artofasm/CH14/CH14–3.html - Art of Assembly language programming: The FPU Instruction Set
https://courses.engr.illinois.edu/ece390/books/artofasm/CH14/CH14–4.html - INTEL 80387 PROGRAMMER'S REFERENCE MANUAL
http://www.ragestorm.net/downloads/387intel.txt - x86 Instruction Set Reference: FLD
http://x86.renejeschke.de/html/file_module_x86_id100.html - x86 Instruction Set Reference: FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZ
http://x86.renejeschke.de/html/file_module_x86_id101.html - X86 Assembly/Arithmetic
https://en.wikibooks.org/wiki/X86_Assembly/Arithmetic - 8087 Numeric Data Processor
https://www.eeeguide.com/8087-numeric-data-processor/ - Data Types and Instruction Set of 8087 co-processor
https://www.eeeguide.com/data-types-and-instruction-set-of-8087-co-processor/ - 8087 instruction set and examples
https://studylib.net/doc/5625221/8087-instruction-set-and-examples - GCC documentation: Extensions to the C Language Family
https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions - GCC documentation: Using Vector Instructions through Built-in Functions
https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html - SSE (Streaming SIMD Extentions)
http://www.songho.ca/misc/sse/sse.html - Timothy A. Chagnon: SSE and SSE2
http://www.cs.drexel.edu/~tc365/mpi-wht/sse.pdf - Intel corporation: Extending the Worldr's Most Popular Processor Architecture
http://download.intel.com/technology/architecture/new-instructions-paper.pdf - SIMD architectures:
http://arstechnica.com/old/content/2000/03/simd.ars/ - Tour of the Black Holes of Computing!: Floating Point
http://www.cs.hmc.edu/~geoff/classes/hmc.cs105…/slides/class02_floats.ppt - 3Dnow! Technology Manual
AMD Inc., 2000 - Intel MMXTM Technology Overview
Intel corporation, 1996 - MultiMedia eXtensions
http://softpixel.com/~cwright/programming/simd/mmx.phpi - AMD K5 („K5“ / „5k86“)
http://www.pcguide.com/ref/cpu/fam/g5K5-c.html - Sixth Generation Processors
http://www.pcguide.com/ref/cpu/fam/g6.htm - Great Microprocessors of the Past and Present
http://www.cpushack.com/CPU/cpu1.html - Very long instruction word (Wikipedia)
http://en.wikipedia.org/wiki/Very_long_instruction_word - CPU design (Wikipedia)
http://en.wikipedia.org/wiki/CPU_design - Bulldozer (microarchitecture)
https://en.wikipedia.org/wiki/Bulldozer_(microarchitecture) - MMX (instruction set)
https://en.wikipedia.org/wiki/MMX_(instruction_set) - Extended MMX
https://en.wikipedia.org/wiki/Extended_MMX - Saturation arithmetic
https://en.wikipedia.org/wiki/Saturation_arithmetic
