Vývoj mikroprocesorů z rodiny 80×86: od Intelu 8086 k čipu 80286

Obsah

1. Kvantitativní a kvalitativní vývoj mikroprocesorů z rodiny 80×86

2. První čtyři generace: od původního Intelu 8086 až k 80486DX4

3. Splňuje rodina 80×86 Moorův zákon?

4. Interní optimalizace: zlepšující se rychlost vykonávání instrukcí

5. Nové instrukce podporované čipem Intel 80186

6. Instrukce PUSH konstanta

7. Ukázka použití instrukce PUSH konstanta

8. Instrukce PUSHA a POPA

9. Ukázka použití instrukcí PUSHA a POPA

10. Znaménkové násobení konstantou

11. Použití instrukce pro znaménkové násobení konstantou

12. Krátká odbočka: instrukce INTO

13. Provedení aritmetické operace s testem na přetečení výsledku

14. Instrukce BOUND pro test, zda index nepřesahuje meze pole

15. Naivní, ovšem nekorektní přerušovací rutina pro instrukci BOUND

16. Korektní varianta přerušovací rutiny pro instrukci BOUND

17. Bitové posuny a rotace o konstantu větší než 1

18. Nepodporované instrukce: POP CS

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Kvantitativní a kvalitativní vývoj mikroprocesorů z rodiny 80×86

Prozatím jsme v tomto seriálu v naprosté většině demonstračních příkladů využívali instrukční sadu původních šestnáctibitových mikroprocesorů Intel 8086 a Intel 8088 (ty jsou z hlediska instrukcí i jejich délky prakticky totožné). Připomeňme si, že se dnes jedná o historické čipy, které byly na trh uvedeny v letech 1978 a 1979. O přibližně dva roky později použila společnost IBM mikroprocesor Intel 8088 jako základní prvek osobního mikropočítače IBM PC, z něhož se postupně vyvinula celá platforma PC, jež se dodnes vyvíjí a používá (se všemi výhodami a zápornými vlastnostmi tohoto vývoje).

Ovšem postupně se vyvíjely i mikroprocesory odvozené od původního poměrně primitivního Intelu 8086 (resp. jeho ořezané varianty Intel 8088). Rozšiřovala se instrukční sada o nové instrukce a adresovací režimy, přidávaly se nové pracovní registry, přidávaly se nové režimy činnosti mikroprocesoru (chráněný režim 286, odlišný chráněný režim 386, virtuální režim) atd. Ovšem současně se kromě těchto kvantitativních změn vylepšovala i interní architektura mikroprocesorů, což například vedlo k urychlení instrukcí. U řady instrukcí jsme tak postupně došli od jejich vykonání v několika desítkách strojových cyklů například na jediný strojový cyklus a poté na možnost dokončit v jednom cyklu více souběžně prováděných instrukcí.

2. První čtyři generace: od původního Intelu 8086 až k 80486DX4

V řadě x86 nalezneme několik desítek (dnes možná i několik set) různých mikroprocesorů. Zaměřme se tedy nejprve na první čtyři generace řady x86, která začíná již výše zmíněným mikroprocesorem Intel 8086 a končí mikroprocesorem 80486DX4, jenž je z pohledu frekvence přibližně dvacetkrát rychlejší, než původní 8086, ovšem díky optimalizacím ve skutečnosti dosahuje více než osmdesátinásobného(!) výpočetního výkonu v porovnání s první verzí 8086 (nehledě na to, že v 80486DX4 je i matematický koprocesor a rapidně se zvýšilo i množství adresovatelné paměti).

Podívejme se na následující tabulku, v níž jsou vypsány všechny důležité mikroprocesory řady x86 (neboli, pokud použijeme alternativní označení, rodiny 80×86) vyráběné společností Intel a patřící do prvních čtyř generací:

3. Splňuje rodina 80×86 Moorův zákon?

Do tabulky uvedené v předchozí kapitole byly zapsány i přibližné počty tranzistorů u jednotlivých typů mikroprocesorů. Vzhledem k tomu, že se jedná o mikroprocesory společnosti Intel, jejímž zakladatelem je Gordon Moore, bude zajímavé zjistit, jestli i mikroprocesory řady x86 dobře odpovídají Moorovu zákonu, který říká (říkal), že každé dva roky dochází ke zdvojnásobení počtu tranzistorů na čipech s velkou integrací (a sem mikroprocesory pochopitelně spadají). Zkusme si tedy vykreslit grafy s počty tranzistorů u prvních čtyř generací mikroprocesorů řady x86 a současně teoretické počty tranzistorů odpovídajících Moorovu zákonu v případě, že v roce 1978 začneme s 10000 tranzistory resp. s 25000 tranzistory (začneme tedy o něco níže, než 29000 tranzistorů u původního Intelu 8086).

Zobrazíme si jak graf s lineárním měřítkem na vertikální ose, tak i přehlednější graf, který má na vertikální ose měřítko logaritmické:

Obrázek 1: Počet tranzistorů na mikroprocesorech rodiny 80×86 vs. Moorův zákon (lineární měřítko na y-ové ose).

Obrázek 2: Počet tranzistorů na mikroprocesorech rodiny 80×86 vs. Moorův zákon (logaritmické měřítko na y-ové ose).

4. Interní optimalizace: zlepšující se rychlost vykonávání instrukcí

Postupně rostoucí počet tranzistorů sám o sobě ovšem nic nevypovídá o skutečné rychlosti mikroprocesoru, protože do značné míry záleží na tom, jakým způsobem jsou tyto tranzistory využity. Postupně rostoucí kvalita implementace instrukcí (například přidáním nové specializované sčítačky pro výpočty adres, přidání fronty instrukcí, možnost takzvaného prefetchingu instrukcí, implementace RISCové pipeline atd.) vedla k tomu, že se postupně snižoval počet cyklů nutných pro dokončení instrukcí. To tedy znamená, že i když mohl být jak mikroprocesor Intel 8086, tak i Intel 80286 provozován na stejné frekvenci 8MHz, bude 80286 ve skutečnosti rychlejší. Ukažme si to například na základní instrukci součtu dvou osmibitových nebo šestnáctibitových hodnot – ADD. Délka výpočtů se odlišuje podle typů operandů a taktéž podle typu mikroprocesoru (čím menší číslo je v tabulce uvedeno, tím lépe):

Přičemž u čipů 8086/8088 se přidává několik cyklů pro EA neboli pro výpočet efektivní adresy:

Navíc, pokud se mění (explicitně specifikuje) segmentový registr, je nutné přičíst další dva hodinové cykly.

5. Nové instrukce podporované čipem Intel 80186

Po mikroprocesorech Intel 8086 a Intel 8088 (1978 a 1979) následoval v roce 1982 mikroprocesor Intel 80186. Ten se používal spíše ve funkci mikrořadiče, takže z pohledu vývoje IBM PC je poněkud méně zajímavý. Ovšem důležité je, že právě do 80186 byly přidány některé instrukce, které v původní instrukční sadě relativně citelně chyběly. Jedná se o instrukce, o nichž se stále (chybně) píše jako o instrukcích přidaných až v 80286. Ovšem ve skutečnosti byly do 80286 přidány „jen“ instrukce související s chráněným režimem.

V následující tabulce jsou vypsány ty instrukce, které bylo možné použít již v mikroprocesoru 80186:

6. Instrukce PUSH konstanta

První novou instrukcí, s níž se dnes setkáme, je instrukce PUSH konstanta, což je varianta instrukce určené pro uložení nějaké hodnoty na zásobník. Původní čipy 8086/8088 podporovaly uložení obsahu libovolného šestnáctibitového registru, uložení obsahu segmentového registru nebo uložení šestnáctibitové hodnoty přečtené z paměti. Nová forma podporuje i uložení šestnáctibitové konstanty.

Instrukci PUSH, která dokáže na zásobník uložit šestnáctibitovou konstantu, můžeme použít například ve chvíli, kdy je zapotřebí konstantu přenést do nějakého segmentového registru. Taková operace by se mohla provést instrukcí MOV, jenže varianta MOV segment_registr, konstanta není dostupná, a to ani v dalších třech generacích čipů rodiny 80×86.

7. Ukázka použití instrukce PUSH konstanta

Podívejme se na příklad, který jsme si již v tomto seriálu ukazovali. Tento příklad po svém spuštění naplní obrazovou paměť v textovém režimu různými hodnotami znaků+atributů. Přitom se obrazová paměť adresuje přes segmentový registr ES. V původní variantě jsme prováděli naplnění ES takto:

        mov ax, 0xb800     ; video RAM v textovem rezimu
        mov es, ax

Nyní provedeme odlišnou sekvenci operací a nezničíme si tak obsah registru AX (ovšem na úkor rychlosti – tato varianta trvá delší počet cyklů):

        push 0xb800     ; video RAM v textovem rezimu
        pop  es

Délka obou řešení je rozdílná, protože druhé řešení je o jeden bajt kratší:

B800B8      mov ax, 0xb800
8EC0        mov es, ax
 
6800B8      push 0xb800
07          pop  es

Upravený zdrojový kód demonstračního příkladu vypadá následovně:

;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
;-----------------------------------------------------------------------------
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        mov     ah, 0x4c
        int     0x21
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
; nastaveni grafickeho rezimu
%macro gfx_mode 1
        mov     ah, 0
        mov     al, %1
        int     0x10
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        gfx_mode 3      ; nastaveni standardniho textoveho rezimu 80x25 znaku
 
        push 0xb800     ; video RAM v textovem rezimu
        pop  es
        mov di, 0       ; nyni ES:DI obsahuje adresu prvniho znaku ve video RAM
 
        mov cx, 80*25   ; pocet zapisovanych znaku
        mov al, 0       ; kod zapisovaneho znaku
opak:
        stosb           ; zapis znaku + atributu
        stosb
        inc al          ; dalsi znak/atribut
        loop opak       ; opakujeme CX-krat
 
        mov dx, 0x3d8   ; port s rizenim graficke palety
        mov al, 0x18    ; pozadi neblika, meni se intenzita
        out dx, al      ; pres port 0x3d9
 
        wait_key
 
        mov dx, 0x3d8   ; port s rizenim graficke palety
        mov al, 0x38    ; pozadi opet blika, nizka intenzita
        out dx, al      ; pres port 0x3d9
 
        wait_key
 
        wait_key        ; cekani na klavesu
        exit            ; navrat do DOSu

8. Instrukce PUSHA a POPA

V mnoha situacích se setkáme s nutností uložení většího množství registrů na zásobník. Tato operace trvá na 80186 deset cyklů a na 80286 tři cykly. Pokud je zapotřebí uložit více registrů, použije se více těchto instrukcí a časy se pochopitelně sčítají. Instrukce PUSHA naproti tomu uloží všechny pracovní registry v pořadí AX, CX, DX, BX, SP, BP, SI, DI a celková doba jejího trvání je 36 resp. 17 cyklů (v dalších generacích ještě méně).

Podobně instrukce POP jednoho registru trvá 10 resp. 5 cyklů pro každý registr, zatímco POPA provede obnovení registrů v pořadí DI, SI, BP, SP, BX, DX, CX, AX a celková doba jejího trvání je 51 resp. 19 cyklů. To znamená, že pokud ukládáme/obnovujeme čtyři nebo více registrů, je výhodnější použít PUSHA+POPA, což je i mnohem kratší řešení z pohledu délky strojového kódu.

9. Ukázka použití instrukcí PUSHA a POPA

S instrukcemi PUSHA a POPA jsme se setkali při programování obsluhy nějakého přerušení. Typická přerušovací rutina totiž na svém začátku uloží všechny v ní použité registry na zásobník a na konci je zase obnoví. V případě, že se nám nechce sledovat, které registry uložit (a poté obnovit) sekvencí instrukcí PUSH a posléze POP, nebo pokud je registrů větší množství, použijeme právě PUSHA a POPA. Připomeňme si, jak taková rutina může vypadat:

int8_handler:                   ; nova obsluha preruseni
        pusha                   ; ulozit vsechny registry
        print_char 't'          ; t=tick
 
        mov al, 0x20
        out 0x20, al            ; oznameni, ze preruseni je u konce radici preruseni 
 
        popa                    ; obnovit vsechny registry
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni

Způsob překladu do strojového kódu naznačuje, jak krátké (z pohledu obsazení paměti) tyto instrukce ve skutečnosti jsou:

        int8_handler:                   ; nova obsluha preruseni
60              pusha                   ; ulozit vsechny registry
                print_char 't'          ; t=tick
B402            mov ah, 0x02
B274            mov dl, %1
CD21            int 0x21
 
B020            mov al, 0x20
E620            out 0x20, al            ; oznameni, ze preruseni je u konce radici preruseni 
 
61              popa                    ; obnovit vsechny registry
FB              sti                     ; povoleni maskovatelnych preruseni
CF              iret                    ; navrat z preruseni

10. Znaménkové násobení konstantou

Další nová varianta instrukce, se kterou jsme se mohli setkat u čipů Intel 80186 (a samozřejmě i u všech mikroprocesorů, které následovaly) je násobení se znaménkem, v podobě, kdy je druhým operandem konstanta a kdy je specifikován i registr, do kterého se má uložit výsledek. Jedná se o instrukci IMUL, která má velké množství variant. Vypišme si jen osmibitové a šestnáctibitové varianty. V poznámce je uvedeno, od jakého čipu jsou tyto varianty dostupné:

IMUL reg8
IMUL reg16
IMUL mem8
IMUL mem16
IMUL reg16, konstanta         ; od 286
IMUL reg16, reg16, konstanta  ; od 186
IMUL reg16, mem16, konstanta  ; od 186
IMUL reg16, reg16             ; od 386
IMUL reg16, mem16             ; od 386

11. Použití instrukce pro znaménkové násobení konstantou

Vlastní použití instrukce IMUL reg16, reg16, konstanta je snadné, jak je to ostatně patrné i z následujícího demonstračního příkladu, v němž vynásobíme obsah registru BX dvěma, takže výsledkem bude hexadecimální hodnota 0×06:

; Instrukcni soubor mikroprocesoru Intel 80286.
; Test instrukce IMUL s konstantnim operandem.
;
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        ret
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
; tisk retezce na obrazovku
%macro print 1
        mov     dx, %1
        mov     ah, 9
        int     0x21
%endmacro
 
; tisk hexadecimalni hodnoty
%macro print_hex 1
        mov     bx, hex_digits
        mov     cl, %1                ; zapamatovat si predanou hodnotu
 
        mov     al, cl                ; do AL se vlozi horni hexa cifra
        and     al, 0xf0
        shr     al, 1
        shr     al, 1
        shr     al, 1
        shr     al, 1
 
        xlat                          ; prevod hodnoty 0-15 na ASCII znak
        mov     [message], al         ; zapis ASCII znaku do retezce
 
        mov     al, cl                ; do BL se vlozi dolni hexa cifra
        and     al, 0x0f
        xlat                          ; prevod hodnoty 0-15 na ASCII znak
        mov     [message + 1], al     ; zapis ASCII znaku do retezce
 
        print   message
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        xor  ax, ax        ; výsledný registr
        mov  bx, 0x03      ; první operand
        imul ax, bx, 2     ; násobení konstantou
        print_hex al       ; výsledek je v AX
 
        wait_key
        exit
 
        ; retezec ukonceny znakem $
        ; (tato data jsou soucasti vysledneho souboru typu COM)
message db 0x01, 0x01, 0x0d, 0x0a, "$"
 
        ; prevodni tabulka hodnoty 0-15 na ASCII znak
hex_digits db "0123456789abcdef"

Výše uvedená varianta IMUL je přeložena do tříbajtové sekvence:

    58 00000000 31C0        xor  ax, ax        ; výsledný registr
    59 00000002 BB0300      mov  bx, 0x03      ; první operand
    60 00000005 6BC302      imul ax, bx, 2     ; násobení konstantou

12. Krátká odbočka: instrukce INTO

Ještě před popisem dalších instrukcí, které byly přidány do instrukčního souboru mikroprocesoru Intel 80186 se na chvíli zastavme u instrukce původního Intelu 8086, kterou jsme si ještě nepopsali. Jedná se o instrukci nazvanou INTO, což je instrukce, jejíž mnemotechnická zkratka vznikla ze slov „(call) interrupt procedure if overflow“. Tato instrukce zkontroluje obsah příznakového bitu overflow (OF) a pokud je tento bit nastaven, vyvolá se přerušení číslo 4, tj. provede se vlastně instrukce INT 4. Tuto instrukci tedy může do programového kódu vkládat například překladač vyššího programovacího jazyka ve chvíli, kdy je povolena kontrola přetečení výsledků (příkladem může být Pascal atd.) a kdy se má vždy vyvolat stejná přerušovací rutina. Není tedy nutné provádět instrukce JO/JNO, které jsou zbytečně dlouhé, protože instrukce INTO je zakódována do jediného bajtu.

13. Provedení aritmetické operace s testem na přetečení výsledku

Vyzkoušejme si nyní, jak vlastně může vypadat obsluha přerušení, která vypíše nějaké hlášení ve chvíli, kdy při výpočtech dojde k přetečení:

int4_handler:                   ; obsluha preruseni cislo 4
        pusha                   ; ulozit vsechny registry
        print overflow_msg
        popa                    ; obnovit vsechny registry
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni

Tuto přerušovací rutinu musíme pochopitelně zapsat do tabulky vektorů přerušení:

INT_4_VECTOR equ 4*4 ; adresa vektoru preruseni
 
        xor  ax, ax
        mov  es, ax
        mov  di, INT_4_VECTOR   ; ES:DI obsahuje adresu, na ktere je adresa obsluhy preruseni 4
 
        cli                     ; zakaz preruseni
        lea  ax, int4_handler   ; zmena offsetove casti adresy
        mov  es:[di], ax
 
        mov  ax, cs             ; zmena segmentove casti adresy
        mov  es:[di+2], ax
        sti                     ; povoleni preruseni

A následně již můžeme po výpočtech použít instrukci INTO pro test, zda došlo k přetečení či nikoli:

        mov  al, 10
        add  al, al             ; soucet dvou hodnot
        into                    ; test na preteceni -> vyvolani preruseni

popř. 

        mov  al, 100
        add  al, al             ; soucet dvou hodnot
        into                    ; test na preteceni -> vyvolani preruseni

14. Instrukce BOUND pro test, zda index nepřesahuje meze pole

Další instrukcí určenou primárně pro strojový kód generovaný překladači vyšších programovacích jazyků je instrukce nazvaná BOUND. Tato instrukce kontroluje, zda nějaký šestnáctibitový index uložený v libovolném pracovním registru nepřesahuje dolní nebo horní mez rozsahu pole, přičemž tento rozsah je uložen v operační paměti na specifikované adrese (první dva bajty obsahují dolní index, další dva bajty obsahují index horní). Představme si například zdrojový kód napsaný v Pascalu, v němž je možné specifikovat horní i dolní meze indexů polí:

arr : Array[10..20] Of Integer;

Povolené indexy tedy začínají od 10 a končí u 20. Pokud je pole v operační paměti uloženo takovým způsobem, že první čtyři bajty obsahují meze indexů polí (což je poměrně triviální a přitom praktický způsob uložení pole) a pokud je index, s nímž pracujeme, uložen například v registru AX, můžeme zkontrolovat, jestli je index korektní, takto:

     bound ax, [pole]

V případě, že index leží v potřebném rozsahu, instrukce po 35(!) taktech skončí. Pokud však index leží mimo rozsah, vyvolá se přerušení INT 5 (nikoli INT 4, jako u INTO). A samozřejmě i na tuto skutečnost můžeme potřebným způsobem reagovat vlastní přerušovací rutinou.

15. Naivní, ovšem nekorektní přerušovací rutina pro instrukci BOUND

Zkusme si nyní zaregistrovat rutinu nazvanou int5_handler, která bude zavolána ve chvíli, kdy dojde k přerušení číslo 5, ať již vlivem instrukce INT 5 nebo nepřímo přes instrukci BOUND. Samotná registrace takové rutiny se nijak neliší od registrace rutiny pro přerušení číslo 4, pochopitelně se však bude provádět zápis na jiné místo tabulky přerušovacích vektorů:

INT_5_VECTOR equ 5*4 ; adresa vektoru preruseni
 
        xor  ax, ax
        mov  es, ax
        mov  di, INT_5_VECTOR   ; ES:DI obsahuje adresu, na ktere je adresa obsluhy preruseni 5
 
        cli                     ; zakaz preruseni
        lea  ax, int5_handler   ; zmena offsetove casti adresy
        mov  es:[di], ax
 
        mov  ax, cs             ; zmena segmentove casti adresy
        mov  es:[di+2], ax
        sti                     ; povoleni preruseni

První verze rutiny s obsluhou přerušení může vypadat následovně – pouze vypíšeme zprávu „index out of bounds!“ a subrutinu následně ukončíme:

int5_handler:                   ; obsluha preruseni cislo 5
        pusha                   ; ulozit vsechny registry
        print index_out_of_bounds_msg
        popa                    ; obnovit vsechny registry
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni -> nyni se vracime zpet na instrukci BOUND

Pokusme se nyní tuto subrutinu zavolat – index 100 leží mimo povolený rozsah 0 až 99:

        mov  ax, 100            ; nacteni indexu
        bound ax, [bounds]      ; test indexu
 
bounds  dw 0, 99

Pokud takto upravený demonstrační příklad přeložíme a spustíme, začne se na terminál neustále dokola vypisovat zpráva:

index out of bounds!
index out of bounds!
index out of bounds!
...
...
...

Proč tomu tak je a jak bude možné tento příklad opravit, si řekneme v navazující kapitole. Nyní bude pro úplnost ukázán celý zdrojový kód tohoto demonstračního příkladu:

; Instrukcni soubor mikroprocesoru Intel 80286.
; Instrukce BOUND - nekorektni verze programu.
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
INT_5_VECTOR equ 5*4 ; adresa vektoru preruseni
 
;-----------------------------------------------------------------------------
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        ret
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
; tisk retezce na obrazovku
%macro print 1
        mov     dx, %1
        mov     ah, 9
        int     0x21
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        xor  ax, ax
        mov  es, ax
        mov  di, INT_5_VECTOR   ; ES:DI obsahuje adresu, na ktere je adresa obsluhy preruseni 5
 
        cli                     ; zakaz preruseni
        lea  ax, int5_handler   ; zmena offsetove casti adresy
        mov  es:[di], ax
 
        mov  ax, cs             ; zmena segmentove casti adresy
        mov  es:[di+2], ax
        sti                     ; povoleni preruseni
 
        mov  ax, 100            ; nacteni indexu
        bound ax, [bounds]      ; test indexu
 
        print done_msg          ; vypis zpravy, ze koncime
 
        wait_key
        exit                    ; a skutecne skoncime
 
int5_handler:                   ; obsluha preruseni cislo 5
        pusha                   ; ulozit vsechny registry
        print index_out_of_bounds_msg
        popa                    ; obnovit vsechny registry
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni -> nyni se vracime zpet na instrukci BOUND
 
;-----------------------------------------------------------------------------
bounds  dw 0, 99
 
        ; retezec ukonceny znakem $
        ; (tato data jsou soucasti vysledneho souboru typu COM)
index_out_of_bounds_msg db "index out of bounds!", 13, 10, "$"
 
        ; retezec ukonceny znakem $
        ; (tato data jsou soucasti vysledneho souboru typu COM)
done_msg     db "done.", 13, 10, "$"

16. Korektní varianta přerušovací rutiny pro instrukci BOUND

Důvod, proč jsme se ocitli de facto v nekonečné smyčce, spočívá v tom, že instrukce BOUND před vyvoláním přerušovací rutiny uloží na zásobník adresu instrukce BOUND a nikoli adresu následující instrukce. To znamená, že po dokončení přerušovací rutiny instrukcí IRET se znovu provede test indexu 100 na meze 0..99 a znovu se vyvolá ta stejná subrutina. Musíme se tedy vrátit nikoli přímo na instrukci BOUND, ale za ni. Tato instrukce má délku čtyř bajtů (operační kód + bajt s určením registru + dva bajty s adresou), takže musíme ze zásobníku získat původní adresu a tu zvýšit o hodnotu 4. Jedno z možných řešení může vypadat následovně:

int5_handler:                   ; obsluha preruseni cislo 5
        pusha                   ; ulozit vsechny registry
        print index_out_of_bounds_msg
        popa                    ; obnovit vsechny registry
        pop ax
        add ax, 4               ; preskocit samotnou instrukci BOUND
        push ax
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni -> nyni se ovsem vracime ZA instrukci BOUND

Nyní už by se při spuštění programu mělo na terminálu objevit pouze:

index out of bounds!
done.

Následuje úplný výpis zdrojového kódu tohoto demonstračního příkladu:

; Instrukcni soubor mikroprocesoru Intel 80286.
; Instrukce BOUND - korektni verze programu.
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
INT_5_VECTOR equ 5*4 ; adresa vektoru preruseni
 
;-----------------------------------------------------------------------------
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        ret
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
; tisk retezce na obrazovku
%macro print 1
        mov     dx, %1
        mov     ah, 9
        int     0x21
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        xor  ax, ax
        mov  es, ax
        mov  di, INT_5_VECTOR   ; ES:DI obsahuje adresu, na ktere je adresa obsluhy preruseni 5
 
        cli                     ; zakaz preruseni
        lea  ax, int5_handler   ; zmena offsetove casti adresy
        mov  es:[di], ax
 
        mov  ax, cs             ; zmena segmentove casti adresy
        mov  es:[di+2], ax
        sti                     ; povoleni preruseni
 
        mov  ax, 99             ; nacteni indexu
        bound ax, [bounds]      ; test indexu
 
        mov  ax, 100            ; nacteni indexu
        bound ax, [bounds]      ; test indexu
 
        mov  ax, 101            ; nacteni indexu
        bound ax, [bounds]      ; test indexu
 
        print done_msg          ; vypis zpravy, ze koncime
 
        wait_key
        exit                    ; a skutecne skoncime
 
int5_handler:                   ; obsluha preruseni cislo 5
        pusha                   ; ulozit vsechny registry
        print index_out_of_bounds_msg
        popa                    ; obnovit vsechny registry
        pop ax
        add ax, 4               ; preskocit samotnou instrukci BOUND
        push ax
        sti                     ; povoleni maskovatelnych preruseni
        iret                    ; navrat z preruseni -> nyni se ovsem vracime ZA instrukci BOUND
 
;-----------------------------------------------------------------------------
bounds  dw 0, 99
 
        ; retezec ukonceny znakem $
        ; (tato data jsou soucasti vysledneho souboru typu COM)
index_out_of_bounds_msg db "index out of bounds!", 13, 10, "$"
 
        ; retezec ukonceny znakem $
        ; (tato data jsou soucasti vysledneho souboru typu COM)
done_msg     db "done.", 13, 10, "$"

17. Bitové posuny a rotace o konstantu větší než 1

Mikroprocesory Intel 8086 a Intel 8088 podporovaly úplnou sadu instrukcí pro bitové posuny a rotace:

Posun či rotace je přitom provedena o jeden bit nebo o CL bitů (CL je spodních osm bitů registru CX). U mikroprocesorů 80186 byla navíc přidána možnost posunů a rotací o n bitů, kde n je celočíselná konstanta. Program je tedy možné zkrátit, ovšem pozor je nutné dát na to, že zatímco rotace/posun o jeden bit trvá 2 takty, rotace/posun o n bitů trvá 5+n taktů, což například v praxi znamená, že posun doprava o dva bity je výhodnější provést dvojicí instrukci SHR registr, 1 a nikoli jedinou instrukcí SHR registr, 2.

Podívejme se nyní na úpravu subrutiny pro obarvení pixelu v režimu 320×200×256, v níž namísto několika posunů o jeden bit použijeme posuny o větší počet bitů:

; Vykresleni pixelu
; AX - x-ova souradnice
; BX - y-ova souradnice (staci len BL)
; CL - barva
putpixel:
        mov dx, 0xa000     ; zacatek stranky video RAM
        mov es, dx         ; nyni obsahuje ES stranku video RAM
 
        mov di, ax         ; horizontalni posun pocitany v bajtech
 
        mov ax, bx         ; y-ova souradnice
        shl ax, 6          ; y*64
        add di, ax         ; pricist cast y-oveho posunu
        shl ax, 2          ; y*256
        add di, ax         ; pricist zbytek y-oveho posunu
                           ; -> y*64 + y*256 = y*320
 
        mov [es:di], cl     ; vlastni vykresleni pixelu
 
        ret

Celý program, který nastaví grafický režim 320×200×256 a následně vykreslí několik úseček, lze upravit následovně:

; Graficky rezim karty VGA s rozlisenim 320x200 pixelu.
; Pouziti predpocitane tabulky.
; Vykresleni barevnych usecek.
; Urceno pro 80286 a vyssi.
;
 
 
 
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
;-----------------------------------------------------------------------------
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        mov     ah, 0x4c
        int     0x21
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
; nastaveni grafickeho rezimu
%macro gfx_mode 1
        mov     ah, 0
        mov     al, %1
        int     0x10
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        gfx_mode 0x13       ; nastaveni rezimu 320x200 s 256 barvami
        push 0xa000         ; video RAM v textovem rezimu
        pop  es
        xor di, di          ; nyni ES:DI obsahuje adresu prvniho pixelu ve video RAM
 
        mov ax, 0
opak:
        mov bx, ax          ; y-ová souřadnice
 
        push ax
        mov cl, al          ; barva
        call putpixel       ; vykreslení pixelu
        pop ax
 
        push ax
        mov cl, al          ; barva
        add ax, 10          ; horizontalni posun useky
        call putpixel       ; vykreslení pixelu
        pop ax
 
        push ax
        mov cl, al          ; barva
        add ax, 20          ; horizontalni posun useky
        call putpixel       ; vykreslení pixelu
        pop ax
 
        inc ax              ; pusun x+=1, y+=1
        cmp ax, 200         ; hranice obrazovky?
        jne opak            ; ne-opakujeme
 
        wait_key            ; cekani na klavesu
        exit                ; navrat do DOSu
 
; Vykresleni pixelu
; AX - x-ova souradnice
; BX - y-ova souradnice (staci len BL)
; CL - barva
putpixel:
        mov dx, 0xa000     ; zacatek stranky video RAM
        mov es, dx         ; nyni obsahuje ES stranku video RAM
 
        mov di, ax         ; horizontalni posun pocitany v bajtech
 
        mov ax, bx         ; y-ova souradnice
        shl ax, 6          ; y*64
        add di, ax         ; pricist cast y-oveho posunu
        shl ax, 2          ; y*256
        add di, ax         ; pricist zbytek y-oveho posunu
                           ; -> y*64 + y*256 = y*320
 
        mov [es:di], cl     ; vlastni vykresleni pixelu
 
        ret

18. Nepodporované instrukce: POP CS

V rámci postupného rozšiřování instrukční sady mikroprocesorů rodiny 80×86 se ukázalo, že některé instrukce nejsou užitečné a je tak možné jejich instrukční kód použít pro odlišné účely. Při přechodu z Intelu 8086/8088 na 80186/80286 došlo k jediné takové úpravě, která se konkrétně týkala instrukce POP CS s operačním kódem 0×0F. Tato instrukce ze zásobníku přečte šestnáctibitovou hodnotu a tu vloží do segmentového registru CS, čímž se ovlivní i adresa další instrukce, která se má přečíst z adresy CS:IP. POP CS sama o sobě prakticky nedává smysl, protože většinou bude na zásobníku plná adresa segment:offset a v tomto případě lze použít plnohodnotný „dlouhý“ RET. Proto byla instrukce POP CS odstraněna a její operační kód je v novějších typech mikroprocesorů použit pro odlišné účely.

Assemblery nás většinou budou varovat, pokud se POP CS pokusíme použít a současně budeme specifikovat, že cílový procesor je odlišný od původního 8086. Nicméně příslušný instrukční kód většinou do výsledného binárního programu vloží:

; Instrukcni soubor mikroprocesoru Intel 80386.
;
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
CPU 286         ; specifikace pouziteho instrukcniho souboru
 
; ukonceni procesu a navrat do DOSu
%macro exit 0
        ret
%endmacro
 
; vyprazdneni bufferu klavesnice a cekani na klavesu
%macro wait_key 0
        xor     ax, ax
        int     0x16
%endmacro
 
;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        push cs
        push ds
        push ss
        push es
 
        pop  es
        pop  ss
        pop  ds
        pop  cs
 
        wait_key
        exit

Ve výsledném programu (resp. v binárním souboru typu COM) bude na třicátém pátém bajtu skutečně operační kód instrukce POP CS:

    35 00000007 0F                              pop  cs

Nicméně současně nás bude assembler varovat, že výsledek nebude plně kompatibilní s cílovým procesorem:

    35          ******************       warning: instruction obsolete and removed from the target CPU [-w+obsolete-removed]

Pro úplnost – takto vypadá výpis listingu vytvořeného assemblerem při překladu:

     1                                  ; Instrukcni soubor mikroprocesoru Intel 80386.
     2                                  ;
     7                                  ;-----------------------------------------------------------------------------
     8
     9                                  BITS 16         ; 16bitovy vystup pro DOS
    10                                  CPU 286         ; specifikace pouziteho instrukcniho souboru
    11
    12                                  ; ukonceni procesu a navrat do DOSu
    13                                  %macro exit 0
    14                                          ret
    15                                  %endmacro
    16
    17                                  ; vyprazdneni bufferu klavesnice a cekani na klavesu
    18                                  %macro wait_key 0
    19                                          xor     ax, ax
    20                                          int     0x16
    21                                  %endmacro
    22
    23                                  ;-----------------------------------------------------------------------------
    24                                  org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
    25
    26                                  start:
    27 00000000 0E                              push cs
    28 00000001 1E                              push ds
    29 00000002 16                              push ss
    30 00000003 06                              push es
    31
    32 00000004 07                              pop  es
    33 00000005 17                              pop  ss
    34 00000006 1F                              pop  ds
    35 00000007 0F                              pop  cs
    35          ******************       warning: instruction obsolete and removed from the target CPU [-w+obsolete-removed]
    36
    37                                          wait_key
    19 00000008 31C0                <1>  xor ax, ax
    20 0000000A CD16                <1>  int 0x16
    38
    14 0000000C C3                  <1>  ret

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ář:

20. Odkazy na Internetu

1. The Intel 8088 Architecture and Instruction Set
   https://people.ece.ubc.ca/~ed­c/464/lectures/lec4.pdf
2. x86 Opcode Structure and Instruction Overview
   https://pnx.tf/files/x86_op­code_structure_and_instruc­tion_overview.pdf
3. x86 instruction listings (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_instruction_listin­gs
4. x86 assembly language (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_assembly_language
5. Intel Assembler (Cheat sheet)
   http://www.jegerlehner.ch/in­tel/IntelCodeTable.pdf
6. 25 Microchips That Shook the World
   https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world
7. Chip Hall of Fame: MOS Technology 6502 Microprocessor
   https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor
8. Chip Hall of Fame: Intel 8088 Microprocessor
   https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-intel-8088-microprocessor
9. Jak se zrodil procesor?
   https://www.root.cz/clanky/jak-se-zrodil-procesor/
10. Apple II History Home
    http://apple2history.org/
11. The 8086/8088 Primer
    https://www.stevemorse.or­g/8086/index.html
12. flat assembler: Assembly language resources
    https://flatassembler.net/
13. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
14. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
15. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
16. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
17. Bit banging
    https://en.wikipedia.org/wi­ki/Bit_banging
18. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
19. X86 Assembly/Bootloaders
    https://en.wikibooks.org/wi­ki/X86_Assembly/Bootloaders
20. Počátky grafiky na PC: grafické karty CGA a Hercules
    https://www.root.cz/clanky/pocatky-grafiky-na-pc-graficke-karty-cga-a-hercules/
21. 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/
22. Karta EGA: první použitelná barevná grafika na PC
    https://www.root.cz/clanky/karta-ega-prvni-pouzitelna-barevna-grafika-na-pc/
23. RGB Classic Games
    https://www.classicdosgames.com/
24. Turbo Assembler (Wikipedia)
    https://en.wikipedia.org/wi­ki/Turbo_Assembler
25. Microsoft Macro Assembler
    https://en.wikipedia.org/wi­ki/Microsoft_Macro_Assembler
26. IBM Personal Computer (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Personal_Computer
27. Intel 8251
    https://en.wikipedia.org/wi­ki/Intel_8251
28. Intel 8253
    https://en.wikipedia.org/wi­ki/Intel_8253
29. Intel 8255
    https://en.wikipedia.org/wi­ki/Intel_8255
30. Intel 8257
    https://en.wikipedia.org/wi­ki/Intel_8257
31. Intel 8259
    https://en.wikipedia.org/wi­ki/Intel_8259
32. Support/peripheral/other chips – 6800 family
    http://www.cpu-world.com/Support/6800.html
33. Motorola 6845
    http://en.wikipedia.org/wi­ki/Motorola_6845
34. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
35. CRTC operation
    http://www.6502.org/users/an­dre/hwinfo/crtc/crtc.html
36. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
37. Motorola 6845 and bitwise graphics
    https://retrocomputing.stac­kexchange.com/questions/10996/mo­torola-6845-and-bitwise-graphics
38. IBM Monochrome Display Adapter
    http://en.wikipedia.org/wi­ki/Monochrome_Display_Adap­ter
39. Color Graphics Adapter
    http://en.wikipedia.org/wi­ki/Color_Graphics_Adapter
40. Color Graphics Adapter and the Brown color in IBM 5153 Color Display
    https://www.aceinnova.com/en/e­lectronics/cga-and-the-brown-color-in-ibm-5153-color-display/
41. The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller
    https://hackaday.com/2017/05/14/the-modern-retrocomputer-an-arduino-driven-6845-crt-controller/
42. flat assembler: Assembly language resources
    https://flatassembler.net/
43. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
44. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
45. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
46. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
47. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
48. X86 Assembly/Arithmetic
    https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
49. Art of Assembly – Arithmetic Instructions
    http://oopweb.com/Assembly/Do­cuments/ArtOfAssembly/Volu­me/Chapter₆/CH06–2.html
50. ASM Flags
    http://www.cavestory.org/gu­ides/csasm/guide/asm_flag­s.html
51. Status Register
    https://en.wikipedia.org/wi­ki/Status_register
52. Linux assemblers: A comparison of GAS and NASM
    http://www.ibm.com/develo­perworks/library/l-gas-nasm/index.html
53. Programovani v assembleru na OS Linux
    http://www.cs.vsb.cz/gryga­rek/asm/asmlinux.html
54. Is it worthwhile to learn x86 assembly language today?
    https://www.quora.com/Is-it-worthwhile-to-learn-x86-assembly-language-today?share=1
55. Why Learn Assembly Language?
    http://www.codeproject.com/Ar­ticles/89460/Why-Learn-Assembly-Language
56. Is Assembly still relevant?
    http://programmers.stackex­change.com/questions/95836/is-assembly-still-relevant
57. Why Learning Assembly Language Is Still a Good Idea
    http://www.onlamp.com/pub/a/on­lamp/2004/05/06/writegreat­code.html
58. Assembly language today
    http://beust.com/weblog/2004/06/23/as­sembly-language-today/
59. Assembler: Význam assembleru dnes
    http://www.builder.cz/rubri­ky/assembler/vyznam-assembleru-dnes-155960cz
60. Programming from the Ground Up Book – Summary
    http://savannah.nongnu.or­g/projects/pgubook/
61. DOSBox
    https://www.dosbox.com/
62. The C Programming Language
    https://en.wikipedia.org/wi­ki/The_C_Programming_Langu­age
63. Hercules Graphics Card (HCG)
    https://en.wikipedia.org/wi­ki/Hercules_Graphics_Card
64. Complete 8086 instruction set
    https://content.ctcd.edu/cou­rses/cosc2325/m22/docs/emu8086in­s.pdf
65. Complete 8086 instruction set
    https://yassinebridi.github.io/asm-docs/8086_instruction_set.html
66. 8088 MPH by Hornet + CRTC + DESiRE (final version)
    https://www.youtube.com/wat­ch?v=hNRO7lno_DM
67. Area 5150 by CRTC & Hornet (Party Version) / IBM PC+CGA Demo, Hardware Capture
    https://www.youtube.com/wat­ch?v=fWDxdoRTZPc
68. 80×86 Integer Instruction Set Timings (8088 – Pentium)
    http://aturing.umcs.maine­.edu/~meadow/courses/cos335/80×86-Integer-Instruction-Set-Clocks.pdf
69. Colour Graphics Adapter: Notes
    https://www.seasip.info/Vin­tagePC/cga.html
70. Restoring A Vintage CGA Card With Homebrew HASL
    https://hackaday.com/2024/06/12/res­toring-a-vintage-cga-card-with-homebrew-hasl/
71. Demoing An 8088
    https://hackaday.com/2015/04/10/de­moing-an-8088/
72. Video Memory Layouts
    http://www.techhelpmanual.com/89-video_memory_layouts.html
73. Screen Attributes
    http://www.techhelpmanual.com/87-screen_attributes.html
74. IBM PC Family – BIOS Video Modes
    https://www.minuszerodegre­es.net/video/bios_video_mo­des.htm
75. EGA Functions
    https://cosmodoc.org/topics/ega-functions/#the-hierarchy-of-the-ega
76. 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/
77. How 16 colors saved PC gaming – the story of EGA graphics
    https://www.custompc.com/retro-tech/ega-graphics
78. List of 16-bit computer color palettes
    https://en.wikipedia.org/wi­ki/List_of₁₆-bit_computer_color_palettes
79. Why were those colors chosen to be the default palette for 256-color VGA?
    https://retrocomputing.stac­kexchange.com/questions/27994/why-were-those-colors-chosen-to-be-the-default-palette-for-256-color-vga
80. VGA Color Palettes
    https://www.fountainware.com/EX­PL/vga_color_palettes.htm
81. Hardware Level VGA and SVGA Video Programming Information Page
    http://www.osdever.net/Fre­eVGA/vga/vga.htm
82. Hardware Level VGA and SVGA Video Programming Information Page – sequencer
    http://www.osdever.net/Fre­eVGA/vga/seqreg.htm
83. VGA Basics
    http://www.brackeen.com/vga/ba­sics.html
84. Introduction to VGA Mode ‚X‘
    https://web.archive.org/web/20160414072210/htt­p://fly.srk.fer.hr/GDM/ar­ticles/vgamodex/vgamx1.html
85. VGA Mode-X
    https://web.archive.org/web/20070123192523/htt­p://www.gamedev.net/referen­ce/articles/article356.asp
86. Mode-X: 256-Color VGA Magic
    https://downloads.gamedev­.net/pdf/gpbb/gpbb47.pdf
87. Instruction Format in 8086 Microprocessor
    https://www.includehelp.com/embedded-system/instruction-format-in-8086-microprocessor.aspx
88. How to use „AND,“ „OR,“ and „XOR“ modes for VGA Drawing
    https://retrocomputing.stac­kexchange.com/questions/21936/how-to-use-and-or-and-xor-modes-for-vga-drawing
89. VGA Hardware
    https://wiki.osdev.org/VGA_Hardware
90. Programmer's Guide to Yamaha YMF 262/OPL3 FM Music Synthesizer
    https://moddingwiki.shika­di.net/wiki/OPL_chip
91. Does anybody understand how OPL2 percussion mode works?
    https://forum.vcfed.org/in­dex.php?threads/does-anybody-understand-how-opl2-percussion-mode-works.60925/
92. Yamaha YMF262 OPL3 music – MoonDriver for OPL3 DEMO [Oscilloscope View]
    https://www.youtube.com/watch?v=a7I-QmrkAak
93. Yamaha OPL vs OPL2 vs OPL3 comparison
    https://www.youtube.com/wat­ch?v=5knetge5Gs0
94. OPL3 Music Crockett's Theme
    https://www.youtube.com/wat­ch?v=HXS008pkgSQ
95. Bad Apple (Adlib Tracker – OPL3)
    https://www.youtube.com/wat­ch?v=2lEPH6Y3Luo
96. FM Synthesis Chips, Codecs and DACs
    https://www.dosdays.co.uk/to­pics/fm_synthesizers.php
97. The Zen Challenge – YMF262 OPL3 Original (For an upcoming game)
    https://www.youtube.com/wat­ch?v=6JlFIFz1CFY
98. [adlib tracker II techno music – opl3] orbit around alpha andromedae I
    https://www.youtube.com/wat­ch?v=YqxJCu_WFuA
99. [adlib tracker 2 music – opl3 techno] hybridisation process on procyon-ii
    https://www.youtube.com/wat­ch?v=daSV5mN0sJ4
100. Hyper Duel – Black Rain (YMF262 OPL3 Cover)
     https://www.youtube.com/wat­ch?v=pu_mzRRq8Ho
101. IBM 5155–5160 Technical Reference
     https://www.minuszerodegre­es.net/manuals/IBM/IBM_5155_5160_Techni­cal_Reference_6280089_MAR86­.pdf
102. a ymf262/opl3+pc speaker thing i made
     https://www.youtube.com/watch?v=E-Mx0lEmnZ0
103. [OPL3] Like a Thunder
     https://www.youtube.com/wat­ch?v=MHf06AGr8SU
104. (PC SPEAKER) bad apple
     https://www.youtube.com/wat­ch?v=LezmKIIHyUg
105. Powering devices from PC parallel port
     http://www.epanorama.net/cir­cuits/lptpower.html
106. Magic Mushroom (demo pro PC s DOSem)
     http://www.crossfire-designs.de/download/articles/sou­ndcards//mushroom.rar
107. Píseň Magic Mushroom – originál
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_con­verted.mp3
108. Píseň Magic Mushroom – hráno na PC Speakeru
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_spe­aker.mp3
109. Pulse Width Modulation (PWM) Simulation Example
     http://decibel.ni.com/content/docs/DOC-4599
110. Resistor/Pulse Width Modulation DAC
     http://www.k9spud.com/trax­mod/pwmdac.php
111. Class D Amplifier
     http://en.wikipedia.org/wi­ki/Electronic_amplifier#Clas­s_D
112. Covox Speech Thing / Disney Sound Source (1986)
     http://www.crossfire-designs.de/index.php?lang=en&what=ar­ticles&name=showarticle.htm&ar­ticle=soundcards/&page=5
113. Covox Digital-Analog Converter (Rusky, obsahuje schémata)
     http://phantom.sannata.ru/kon­kurs/netskater002.shtml
114. PC-GPE on the Web
     http://bespin.org/~qz/pc-gpe/
115. Keyboard Synthesizer
     http://www.solarnavigator­.net/music/instruments/ke­yboards.htm
116. FMS – Fully Modular Synthesizer
     http://fmsynth.sourceforge.net/
117. Javasynth
     http://javasynth.sourceforge.net/
118. Software Sound Synthesis & Music Composition Packages
     http://www.linux-sound.org/swss.html
119. Mx44.1 Download Page (software synthesizer for linux)
     http://hem.passagen.se/ja_linux/
120. Software synthesizer
     http://en.wikipedia.org/wi­ki/Software_synthesizer
121. Frequency modulation synthesis
     http://en.wikipedia.org/wi­ki/Frequency_modulation_syn­thesis
122. Yamaha DX7
     http://en.wikipedia.org/wi­ki/Yamaha_DX7
123. Wave of the Future
     http://www.wired.com/wired/ar­chive/2.03/waveguides_pr.html
124. Analog synthesizer
     http://en.wikipedia.org/wi­ki/Analog_synthesizer
125. Minimoog
     http://en.wikipedia.org/wiki/Minimoog
126. Moog synthesizer
     http://en.wikipedia.org/wi­ki/Moog_synthesizer
127. Tutorial for Frequency Modulation Synthesis
     http://www.sfu.ca/~truax/fmtut.html
128. An Introduction To FM
     http://ccrma.stanford.edu/sof­tware/snd/snd/fm.html
129. John Chowning
     http://en.wikipedia.org/wi­ki/John_Chowning
130. I'm Impressed, Adlib Music is AMAZING!
     https://www.youtube.com/wat­ch?v=PJNjQYp1ras
131. Milinda- Diode Milliampere ( OPL3 )
     https://www.youtube.com/wat­ch?v=oNhazT5HG0E
132. Dune 2 – Roland MT-32 Soundtrack
     https://www.youtube.com/wat­ch?v=kQADZeB-z8M
133. Interrupts
     https://wiki.osdev.org/In­terrupts#Types_of_Interrup­ts
134. Assembly8086SoundBlasterDma­SingleCycleMode
     https://github.com/leonardo-ono/Assembly8086SoundBlas­terDmaSingleCycleMode/blob/mas­ter/sbsc.asm
135. Interrupts in 8086 microprocessor
     https://www.geeksforgeeks­.org/interrupts-in-8086-microprocessor/
136. Interrupt Structure of 8086
     https://www.eeeguide.com/interrupt-structure-of-8086/