Matematické koprocesory na platformě 80×86 prakticky

Obsah

1. Matematické koprocesory na platformě 80×86 prakticky

2. Rychlost matematického koprocesoru v porovnání se SW výpočty

3. Otestování, zda je matematický koprocesor nainstalován

4. Základní aritmetické operace v praxi

5. První demonstrační příklad: základní aritmetické operace

6. Operace podílu, podíl s prohozenými operandy

7. Dělení nulou

8. Demonstrační příklady: dělení kladnou a zápornou nulou

9. Speciální případ: výpočet 0/0

10. Další výpočty, které dokáže matematický koprocesor provádět

11. Demonstrační příklad: výpočet druhé odmocniny

12. Demonstrační příklad: výpočet druhé odmocniny ze záporné hodnoty

13. Řídicí registr matematického koprocesoru

14. Demonstrační příklad: detekce typu matematického koprocesoru

15. Stavový registr matematického koprocesoru

16. Změna ukazatele na vrchol zásobníku při manipulaci s operandy

17. Analýza obsahu stavového registru s ohledem na naplnění zásobníku

18. Pomocný program pro převod FPU hodnot do jejich hexadecimální podoby

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

20. Odkazy na Internetu

1. Matematické koprocesory na platformě 80×86 prakticky

Na úvodní článek z minulého týdne o matematických koprocesorech na platformě IBM PC dnes navážeme. Ukážeme si totiž několik praktických příkladů, na nichž si ověříme základní funkce poskytované matematickým koprocesorem Intel 8087, včetně jeho dalších vlastností (zásobník operandů atd.). Tento čip je sice dnes již muzeálním kouskem, ovšem navazuje na něj řada čipů 80287 a 80387. Posléze se funkce poskytované těmito matematickými koprocesory staly přímo součástí hlavního mikroprocesoru a podporovány jsou dodnes (zde nemluvíme o SIMD variantách).

Interně se jedná o poměrně složitý čip, ovšem i přesto museli inženýři šetřit jak plochou čipu, tak i velikostí mikrokódu, který byl omezen na přibližně 32kB. To mj. znamenalo, že se pro výpočty transcendentních funkcí použilo relativně malé množství mikroinstrukcí (realizován byl algoritmus CORDIC) a tudíž jsou některé výpočty nepřesné, popř. navíc s omezeným definičním rozsahem. To se týká především výpočtu tangens a arkus tangens a u pozdějších čipů i výpočtu sinů a kosinů. Později byla tato omezení odstraněna a i přesnost výpočtů se zvýšila. Nicméně při použití 8087 je nutné tato omezení mít stále na paměti.

2. Rychlost matematického koprocesoru v porovnání se SW výpočty

Původní matematické koprocesory 8087 byly nabízeny ve třech variantách s frekvencemi 5MHz, 8MHz a 10MHz (a tomu odpovídala cena od zhruba 150 dolarů až 270 dolarů). U původní verze 8087 se uváděla výpočetní rychlost dosahující až 50000 FLOPS, což průměrně odpovídá 20µs pro provedení jedné operace. Ovšem musíme k tomu připočítat i instrukce nutné pro načtení a uložení hodnot do operační paměti atd. Nicméně i za těchto podmínek byla rychlost provádění výpočtů matematickým koprocesorem mnohem rychlejší, než softwarové implementace těchto výpočtů. Podívejme se na tabulku s časy provádění vybraných matematických operací (v µs), přičemž je použita frekvence hodin 5 MHz:

Pro zajímavost se ještě podívejme na tabulku, která uvádí relativní rychlost operace FMUL (součin) na čipech, které následovaly po původní 8087:

3. Otestování, zda je matematický koprocesor nainstalován

Jednou z prvních praktických operací je detekce, zda je matematický koprocesor vůbec nainstalován. Tato detekce vlastně není vůbec triviální. U PC XT se musel po instalaci koprocesoru ještě přehodit switch na základní desce, viz například https://www.dosdays.co.uk/to­pics/xt_dip_switches.php. Hodnotu tohoto přepínače bylo možné přečíst přes čip 8255 (s nímž jsme se seznámili). U PX AT a obecně u počítačů vybavených minimálně mikroprocesorem 80286, již bylo možné matematický koprocesor detekovat přečtením stavového slova MSW (machine status word), konkrétně třetího nejnižšího bitu (ten byl později zkopírován do registru CR0, kde lze ještě rozlišit mezi staršími a novějšími verzemi, později ještě přibyla instrukce CPUID). Detekci koprocesoru z obsahu MSW je možné provést následujícím způsobem:

; Otestovani, jestli je nainstalovan matematicky koprocesor.
; Kompatibilni i s cipem Intel 80286
;-----------------------------------------------------------------------------
 
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
 
;-----------------------------------------------------------------------------
org  0x100                     ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        smsw ax                    ; prenos MSW do registru AX
        test ax, 0x4               ; test tretiho nejnizsiho bitu MSW (EM)
 
        jz fpu_present             ; nulovy bit? -> 80287 je nainstalovan
        print fpu_not_present_message  ; nenulovy bit? -> koprocesor chybi
        jmp end
fpu_present:
        print fpu_present_message
end:
        wait_key                   ; cekani na stisk klavesy
        exit                       ; navrat do DOSu
 
; datova cast
fpu_present_message:
    db "FP unit is present", 0x0a, 0x0d, "$"
 
fpu_not_present_message:
    db "FP unit is NOT present", 0x0a, 0x0d, "$"

4. Základní aritmetické operace v praxi

V předchozím článku jsme se taktéž seznámili s instrukcemi matematického koprocesoru určenými pro provedení základních aritmetických operací. Tyto operace jsou prováděny s předem zvolenou přesností a vypočtené výsledky jsou zaokrouhleny předem zvoleným zaokrouhlovacím režimem (k tomu se ještě vrátíme). Připomeňme si, že se jedná o následující instrukce:

U všech těchto instrukcí lze navíc specifikovat příponu P, podobně jako u FST/FSTP. Pokud je tato přípona uvedena, budou ze zásobníku tvořeném pracovními registry odstraněny oba vstupní operandy, a teprve až poté se na zásobník uloží výsledek aritmetické operace.

Způsob načtení konstant do pracovních registrů (a tím pádem i do zásobníku) matematického koprocesoru již známe, takže si nyní již můžeme ukázat, jakým způsobem se v praxi provádí základní aritmetické operace. Začneme podobně jako žáčci v první třídě – součtem dvou jedniček. To se v assembleru provede velmi jednoduše: nejdříve se na vrchol zásobníku, tj. do pracovního registru st(0), uloží první konstanta 1.0, a ve druhém kroku se na posunutý vrchol zásobníku (tj. do sousedního pracovního registru) uloží druhá konstanta 1.0. V kroku třetím se provede instrukce FADDP, která nejenže obě hodnoty uložené na vrcholu zásobníku a těsně pod ním sečte, ale navíc je ještě ze zásobníku odstraní (odstranění druhého operandu je zajištěno použitím FADDP namísto FADD).

Celý výpočet tedy může vypadat takto:

fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
faddp                  ; soucet dvou hodnot na zasobniku
fstp dword ptr number  ; ulozeni do pameti (4 bajty)

Podívejme se nyní na součet tří hodnot, resp. na jednu z možností, jak tento výpočet naprogramovat. Zde můžeme postupovat několika způsoby, z nichž nejjednodušší způsob spočívá v uložení všech tří hodnot na zásobník s následným použitím dvojice instrukcí FADDP. První instrukce sečte poslední dvě hodnoty uložené na zásobníku, takže jeho nový obsah bude [1.0, 2.0], druhá instrukce pak sečte 1.0+2.0 s uložením celkového výsledku zpět:

fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
faddp                  ; soucet poslednich dvou hodnot, ulozeni vysledku zpet na zasobnik
faddp                  ; soucet vsech tri hodnot (1.0+(1.0+1.0))
 
fstp dword ptr number  ; ulozeni do pameti (4 bajty)

V případě, že budeme chtít vynásobit hodnoty 2.0 a 3.0, můžeme oba výpočty spojit dohromady a díky tomu, že zásobník má kapacitu pro osm hodnot, vyhneme se jakýmkoli přesunům dat mezi zásobníkem a operační pamětí (což jsou poměrně pomalé operace, které navíc vyžadují pozastavení mikroprocesoru 8088/8086):

fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
faddp                  ; soucet obou hodnot (1.0+1.0)
                       ; nyni je na zasobniku ulozena hodnota 2
 
fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
fld1                   ; nacteni FP konstanty 1.0
faddp                  ; soucet poslednich dvou hodnot, ulozeni vysledku zpet na zasobnik
faddp                  ; soucet vsech tri hodnot (1.0+(1.0+1.0))
                       ; vysledek 3.0 je ulozen zpet na zasobnik
 
fmulp                  ; nyni jsou na zasobniku ulozeny hodnoty 2 a 3 ktere vynasobime
 
fstp dword ptr number  ; ulozeni do pameti (4 bajty)

5. První demonstrační příklad: základní aritmetické operace

V dnešním prvním demonstračním příkladu je ukázán způsob práce se zásobníkem tvořeným osmi pracovními registry matematického koprocesoru. Nejprve jsou na zásobník uloženy dvě konstanty 1.0 a následně je proveden součet těchto dvou hodnot s vytištěním výsledku této operace. Dále se provádí dvě po sobě jdoucí operace součtu se třemi hodnotami uloženými na zásobníku. A konečně se v poslední části připraví hodnoty 2.0 a 3.0 kombinacemi instrukcí fld1 a faddp. Tyto hodnoty se následně vynásobí operací fmulp a výsledek se opět vytiskne na obrazovku MS DOSu:

1.0+1.0:      Hex value: 0x40000000
1.0+1.0+1.0:  Hex value: 0x40400000
2.0*3.0:      Hex value: 0x40C00000

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

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; soucet dvou hodnot na zasobniku
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; soucet dvou hodnot na zasobniku
        faddp                ; soucet dvou hodnot na zasobniku
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; soucet dvou hodnot na zasobniku
 
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; soucet dvou hodnot na zasobniku
        faddp                ; soucet dvou hodnot na zasobniku
 
        fmulp                ; nyni jsou na zasobniku ulozeny hodnoty 2 a 3 ktere vynasobime
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Zajímavé bude zjistit, jak se jednotlivé instrukce matematického koprocesoru přeložily do strojového kódu:

    18                  main:
    19 0000005E D9E8            fld1                 ; nacteni FP konstanty 1.0
    20 00000060 D9E8            fld1                 ; nacteni FP konstanty 1.0
    21 00000062 DEC1            faddp                ; soucet dvou hodnot na zasobniku
    23
    24 00000081 D9E8            fld1                 ; nacteni FP konstanty 1.0
    25 00000083 D9E8            fld1                 ; nacteni FP konstanty 1.0
    26 00000085 D9E8            fld1                 ; nacteni FP konstanty 1.0
    27 00000087 DEC1            faddp                ; soucet dvou hodnot na zasobniku
    28 00000089 DEC1            faddp                ; soucet dvou hodnot na zasobniku
    30
    31 000000A8 D9E8            fld1                 ; nacteni FP konstanty 1.0
    32 000000AA D9E8            fld1                 ; nacteni FP konstanty 1.0
    33 000000AC DEC1            faddp                ; soucet dvou hodnot na zasobniku
    34
    35 000000AE D9E8            fld1                 ; nacteni FP konstanty 1.0
    36 000000B0 D9E8            fld1                 ; nacteni FP konstanty 1.0
    37 000000B2 D9E8            fld1                 ; nacteni FP konstanty 1.0
    38 000000B4 DEC1            faddp                ; soucet dvou hodnot na zasobniku
    39 000000B6 DEC1            faddp                ; soucet dvou hodnot na zasobniku
    40
    41 000000B8 DEC9            fmulp                ; nyni jsou na zasobniku ulozeny hodnoty 2 a 3 ktere vynasobime

6. Operace podílu, podíl s prohozenými operandy

V předchozím demonstračním příkladu jsme si mj. ukázali instrukci FMUL, resp. FMULP sloužící k vynásobení obou vstupních operandů. Dá se tedy předpokládat, že bude existovat i opačná instrukce určená pro dělení operandů. Taková instrukce skutečně existuje a její varianty se jmenují FDIV a FDIVP. Samotné dělení je prováděno obvyklým způsobem, jen si musíme dát pozor na pořadí operandů na zásobníku. Nejdříve provedeme dělení ve chvíli, kdy na vrcholu zásobníku je uložena hodnota 2.0 a pod vrcholem hodnota 1.0:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; součet, takže na zásobníku budou konstanty 1.0 a 2.0
        fdivp                ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledkem bude hodnota 0×3f000000 odpovídající 1/2 neboli 0.5.

Způsob zakódování instrukcí ve strojovém kódu:

    18                  main:
    19 0000005E D9E8            fld1                 ; nacteni FP konstanty 1.0
    20 00000060 D9E8            fld1                 ; nacteni FP konstanty 1.0
    21 00000062 D9E8            fld1                 ; nacteni FP konstanty 1.0
    22 00000064 DEC1            faddp                ; součet, takže na zásobníku budou konstanty 1.0 a 2.0
    23 00000066 DEF9            fdivp                ; vypocet podilu

Instrukce FDIVR resp. FDIVRP taktéž provádí výpočet podílu, ovšem operandy jsou prohozeny. Pokusme se tedy použít tuto instrukci v situaci, kdy zásobník obsahuje naprosto stejné hodnoty, jako příklad předchozí:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; součet, takže na zásobníku budou konstanty 1.0 a 2.0
        fdivrp               ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledkem bude hodnota 0×40000000, která skutečně odpovídá 2.0.

Způsob zakódování instrukcí ve strojovém kódu:

    19                  main:
    20 0000005E D9E8            fld1                 ; nacteni FP konstanty 1.0
    21 00000060 D9E8            fld1                 ; nacteni FP konstanty 1.0
    22 00000062 D9E8            fld1                 ; nacteni FP konstanty 1.0
    23 00000064 DEC1            faddp                ; součet, takže na zásobníku budou konstanty 1.0 a 2.0
    24 00000066 DEF1            fdivrp               ; vypocet podilu

7. Dělení nulou

Zaměřme se nyní na to, co se stane v případě, že se provádí dělení nulou. Navíc je nutné připomenout, že ve formátech single i double (a pochopitelně i extended) je znaménko reprezentováno samostatným bitem, což mj. znamená, že existuje kladná a záporná nula.

Dělení kladnou nulou je jednoduché a lze ho realizovat například takto:

fld1                 ; nacteni FP konstanty 1.0
fldz                 ; nacteni FP konstanty 0.0
fdivp                ; vypocet podilu
 
print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru

Nulou pochopitelně můžeme dělit i zápornou hodnotu, například –1.0. To lze opět realizovat velmi snadno, bez nutnosti načítání konstant z operační paměti:

fld1                 ; nacteni FP konstanty 1.0
fchs                 ; zmena znamenka
fldz                 ; nacteni FP konstanty 0.0
fdivp                ; vypocet podilu
 
print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru

Dělení zápornou nulou (tedy skutečně hodnotou –0.0) vyžaduje taktéž použití instrukce FCHS, která otočí znaménko svého operandu (zde konkrétně oné nuly):

fld1                 ; nacteni FP konstanty 1.0
fldz                 ; nacteni FP konstanty 0.0
fchs                 ; zmena znamenka
fdivp                ; vypocet podilu
 
print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru

8. Demonstrační příklady: dělení kladnou a zápornou nulou

Různé varianty dělení nulou si nyní otestujeme prakticky. Nejdříve je ukázán demonstrační příklad, který provede výpočet 1.0/0.0:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fldz                 ; nacteni FP konstanty 0.0
        fdivp                ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledkem je hodnota 0×7f800000, což odpovídá kladnému nekonečnu.

Ve druhém příkladu je proveden výpočet –1.0/0.0, tj. dělíme zápornou hodnotu kladnou nulou:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fchs                 ; zmena znamenka
        fldz                 ; nacteni FP konstanty 0.0
        fdivp                ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledkem je v tomto případě hodnota 0×ff800000, což odpovídá zápornému nekonečnu (znaménko je uloženo v nejvyšším bitu).

Oba výsledky se tedy od sebe liší jen nejvyšším bitem, což je znaménko. Dále následuje osm bitů exponentu. Tyto bity jsou v obou případech nastaveny na samé jedničky, samotný exponent je pak nulový. To odpovídá tabulce speciálních hodnot, s níž jsme se seznámili minule:

A konečně provedeme výpočet 1.0/-0.0, tj. podíl kladné hodnoty a záporné nuly:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fldz                 ; nacteni FP konstanty 0.0
        fchs                 ; zmena znamenka
        fdivp                ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledek je totožný s předchozím příkladem.

Pro úplnost si ještě ukážeme překlad instrukcí matematického koprocesoru z prvního příkladu do strojového kódu:

    18                  main:
    19 0000005E D9E8            fld1                 ; nacteni FP konstanty 1.0
    20 00000060 D9EE            fldz                 ; nacteni FP konstanty 0.0
    21 00000062 DEF9            fdivp                ; vypocet podilu

9. Speciální případ: výpočet 0/0

Ještě jsme si však nevyzkoušeli další speciální případ – dělení 0/0. I to lze realizovat velmi snadno následujícími třemi instrukcemi:

fldz             ; nacteni FP konstanty 0.0
fldz             ; nacteni FP konstanty 0.0
fdivp            ; vypocet 0.0/0.0

Výsledkem bude hodnota:

0/0:   Hex value: 0xFFC00000

Po převodu na binární tvar a rozdělení bitových polí:

Opět nahlédněme do tabulky zveřejněné minule, abychom zjistili, co tato hodnota znamená:

Vidíme, že vydělením nuly nulou (ať již kladnou či zápornou) získáme speciální hodnotu NaN. Většina dalších instrukcí sice NaN může akceptovat, ale výsledkem operace bude opět NaN, na což je zapotřebí dávat při programování (nejenom v assembleru) pozor.

Úplný zdrojový kód příkladu, který toto dělení provede, vypadá následovně:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fldz                 ; nacteni FP konstanty 0.0
        fldz                 ; nacteni FP konstanty 0.0
        fdivp                ; vypocet podilu
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

10. Další výpočty, které dokáže matematický koprocesor provádět

Matematický koprocesor 8087 dokáže kromě aritmetických operací provádět i některé další výpočty. Pokud se zaměříme na výpočty prováděné s hodnotami s plovoucí řádovou čárkou, bude se jednat o následující instrukce:

Navíc jsou k dispozici i celočíselné operace, které lze poznat podle toho, že začínají prefixem FI. Jejich praktické použití bude ukázáno příště:

FPTAN
FMUL ST(0)  ; druhá mocnina
FLD1
FADDP       ; přičíst jedničku
FSQRT       ; výsledek odmocnit
FLD1
FDIVP       ; převrácená hodnota mezivýsledku

11. Demonstrační příklad: výpočet druhé odmocniny

Pro mnoho praktických algoritmů je důležité umět vypočítat druhou odmocninu nějaké hodnoty. Pro tento účel slouží instrukce nazvaná FSQRT, kterou si nyní otestujeme. V dalším demonstračním příkladu se pokusíme o výpočet druhé odmocniny (kladné) nuly, jedničky a taktéž dvojky:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fldz                 ; nacteni FP konstanty 0.0
        fsqrt                ; vypocet druhe odmocniny
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        fld1                 ; nacteni FP konstanty 1.0
        fsqrt                ; vypocet druhe odmocniny
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        fld1                 ; nacteni FP konstanty 1.0
        fld1                 ; nacteni FP konstanty 1.0
        faddp                ; soucet -> na zasobnik se ulozi hodnota 2.0
        fsqrt                ; vypocet druhe odmocniny
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Po překladu a spuštění tohoto příkladu se zobrazí trojice hexadecimálních hodnot, které si převedeme na desítkové hodnoty s desetinnou čárkou:

00000000 = 0,0
3fb00000 = 1,0
3fb504f3 = 1,4142135

A pro úplnost si ukažme, jak se instrukce FSQRT přeložila do strojového kódu společně s dalšími instrukcemi matematického koprocesoru:

    13                  main:
    14 0000005E D9EE            fldz                 ; nacteni FP konstanty 0.0
    15 00000060 D9FA            fsqrt                ; vypocet druhe odmocniny
    16                          print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
    17
    18 0000007F D9E8            fld1                 ; nacteni FP konstanty 1.0
    19 00000081 D9FA            fsqrt                ; vypocet druhe odmocniny
    20                          print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
    21
    22 000000A0 D9E8            fld1                 ; nacteni FP konstanty 1.0
    23 000000A2 D9E8            fld1                 ; nacteni FP konstanty 1.0
    24 000000A4 DEC1            faddp                ; soucet -> na zasobnik se ulozi hodnota 2.0
    25 000000A6 D9FA            fsqrt                ; vypocet druhe odmocniny
    26                          print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
    27
    28                          wait_key             ; cekani na klavesu
    29                          exit                 ; navrat do DOSu

12. Demonstrační příklad: výpočet druhé odmocniny ze záporné hodnoty

V oboru reálných hodnot není možné vypočítat druhou odmocninu ze záporné hodnoty. Jak se tedy zachová matematický koprocesor v případě, že se o takový výpočet pokusíme? Můžeme si to velmi snadno otestovat, a to pokusem a výpočet druhé odmocniny z hodnoty –1 (kterou snadno získáme kombinací instrukcí FLD1 a FCHS:

org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main             ; skok na zacatek kodu
 
%include "io.asm"            ; nacist symboly, makra a podprogramy
%include "print.asm"         ; nacist symboly, makra a podprogramy
 
main:
        fld1                 ; nacteni FP konstanty 1.0
        fchs                 ; zmena znamenka
        fsqrt                ; vypocet druhe odmocniny
        print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
 
        wait_key             ; cekani na klavesu
        exit                 ; navrat do DOSu

Výsledkem je hexadecimální 32bitová hodnota ffc00000, což odpovídá speciální hodnotě Not A Number. Jedná se v tomto případě o očekávaný výsledek.

Opět se pro úplnost podívejme na způsob překladu tohoto demonstračního příkladu (resp. jeho FPU instrukcí) do strojového kódu:

    13                  main:
    14 0000005E D9E8            fld1                 ; nacteni FP konstanty 1.0
    15 00000060 D9E0            fchs                 ; zmena znamenka
    16 00000062 D9FA            fsqrt                ; vypocet druhe odmocniny
    17                          print_float32_as_hex ; zobrazeni FP hodnoty v hexadecimalnim tvaru
    18
    19                          wait_key             ; cekani na klavesu
    20                          exit                 ; navrat do DOSu

13. Řídicí registr matematického koprocesoru

Mikroprocesor 8087 byl konfigurován přes řídicí registr nazývaný většinou jen CW. Jednalo se o šestnáctibitový registr, který měl následující strukturu:

Pro čtení obsahu tohoto registru se používá instrukce FNSTCW a pro jeho načtení instrukce FLDCW. Obsah registru se přitom ukládá (či načítá) do operační paměti, nikoli do registrů hlavního mikroprocesoru. My tento registr použijeme příště při popisu zaokrouhlovacích režimů.

14. Demonstrační příklad: detekce typu matematického koprocesoru

Řídicí registr matematického koprocesoru lze využít v těch případech, kdy potřebujeme detekovat jeho konkrétní typ. Takový test je většinou nutné provést ještě předtím, než lze zavolat ty instrukce, které byly přidány až do čipu 80387 (SINCOS apod.). K rozlišení typů koprocesorů se využívá faktu, že novější čipy nenastavují ve výchozím stavu bit IE, takže ihned po inicializaci koprocesoru instrukcí FNINIT a po přečtení stavového registru je možné rozlišit hodnoty 0×03ff (původní čipy Intel 8087) od 0×037f (novější čipy). Nejedná se sice o ideální řešení, ale taková je prostě platforma IBM PC bez ústředních „registrů“ s konkrétní konfigurací počítače:

; Otestovani, jestli je k dispozici matematický koprocesor a jakeho je typu.
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
 
;-----------------------------------------------------------------------------
 
; 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:
        jmp main                   ; skok na zacatek kodu
 
main:
        fninit
        mov cx, 100                ; nechame koprocesor "vydechnout"
 
 .wait:
        loop .wait
 
        fnstcw word [test_word]    ; ulozeni ridiciho slova
        cmp word [test_word], 0x03FF  ; vychozi bitova pole ukladana cipem 8087
        je  fpu_8087_present
 
        cmp word [test_word], 0x037F  ; vychozi bitova pole ukladana cipem 80287 a vyssim
        je  fpu_present
 
        print fpu_not_present_message
        jmp end
fpu_8087_present:
        print fpu_8087_present_message
        jmp end
fpu_present:
        print fpu_present_message
end:
        wait_key                   ; cekani na stisk klavesy
        exit                       ; navrat do DOSu
 
; datova cast
test_word: dw 0
 
fpu_8087_present_message:
    db "Math coprocessor 8087 is present", 0x0a, 0x0d, "$"
 
fpu_present_message:
    db "Math coprocessor >8087 is present", 0x0a, 0x0d, "$"
 
fpu_not_present_message:
    db "Math coprocessor is NOT present", 0x0a, 0x0d, "$"

15. Stavový registr matematického koprocesoru

Jednotlivé matematické operace prováděné matematickým koprocesorem nastavují bity v takzvaném stavovém registru (status register), o němž jsme se již zmínili minule. Tento registr má šířku šestnácti bitů a jeho struktura vypadá následovně:

Samotné přečtení a zobrazení stavového slova (registru) matematického koprocesoru je snadné. Opět zde ovšem musíme data mezi koprocesorem a hlavním procesorem přenášet přes operační paměť; v našem ukázkovém příkladu konkrétně přes dvojici bajtů umístěných na adrese test_word:

; Precteni stavoveho slova matematickeho koprocesoru
;-----------------------------------------------------------------------------
 
BITS 16           ; 16bitovy vystup pro DOS
 
;-----------------------------------------------------------------------------
 
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
main:
        fninit                     ; inicializace koprocesoru
        fnstsw word [test_word]    ; ulozeni stavoveho slova
        mov ax, word [test_word]
        print_hex_16 ax            ; tisk stavoveho slova v hexadecimalnim formatu
 
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
;-----------------------------------------------------------------------------
 
; datova cast
test_word: dw 0

Ihned po inicializaci matematického koprocesoru by se měla vypsat tato hodnota:

0000

To znamená, že prozatím nedošlo k žádné výjimce, nedošlo k porovnání operandů, zásobník je prázdný a neprovádí se žádná operace.

16. Změna ukazatele na vrchol zásobníku při manipulaci s operandy

Zásobník operandů, který je realizován osmi pracovními registry matematického koprocesoru, má uložen index svého vrcholu (TOS – Top Of Stack) ve stavovém registru matematického koprocesoru. Konkrétně se jedná o bity ST0, ST1 a ST2, které se mění při ukládání operandů na zásobník a samozřejmě i při jejich vyjímání ze zásobníku. Počáteční index TOS je nastaven na nulu a roste směrem dolů (ovšem musíme mít na paměti, že se nehlídá přetečení ani podtečení, jedná se vlastně o kombinaci kruhové fronty a zásobníku – tedy „kruhový zásobník“?).

V následujícím demonstračním příkladu jsou na zásobník ukládány operandy, popř. jsou naopak operandy vyjímány (při operaci součtu). Mezitím si vždy necháme vypsat obsah stavového registru matematického koprocesoru, abychom zjistili, jak se mění obsah registrů ST0, ST1 a ST2:

; Precteni stavoveho slova matematickeho koprocesoru
; Změna obsazení zásobníku: vliv na obsah stavového slova
;-----------------------------------------------------------------------------
 
BITS 16         ; 16bitovy vystup pro DOS
 
;-----------------------------------------------------------------------------
 
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
main:
        fninit                     ; inicializace koprocesoru
        call print_status_word     ; tisk stavového slova
 
        fldz                       ; uložení hodnoty na zásobník
        call print_status_word     ; tisk stavového slova
 
        fldz                       ; uložení druhé hodnoty na zásobník
        call print_status_word     ; tisk stavového slova
 
        fldz                       ; uložení třetí hodnoty na zásobník
        call print_status_word     ; tisk stavového slova
 
        faddp                      ; výpočet s odstraněním původní hodnoty
        call print_status_word     ; tisk stavového slova
 
        faddp                      ; výpočet s odstraněním původní hodnoty
        call print_status_word     ; tisk stavového slova
 
        faddp                      ; výpočet s odstraněním původní hodnoty
        call print_status_word     ; tisk stavového slova
 
        faddp                      ; nyní by měl zásobník "podtéct"
        call print_status_word     ; tisk stavového slova
 
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
;-----------------------------------------------------------------------------
 
print_status_word:
        fnstsw word [test_word]    ; ulozeni stavoveho slova
        mov ax, word [test_word]
        print_hex_16 ax            ; tisk stavoveho slova v hexadecimalnim formatu
        ret
 
; datova cast
test_word: dw 0

17. Analýza obsahu stavového registru s ohledem na naplnění zásobníku

Podívejme se nyní na zobrazené hodnoty stavového registru i na jejich význam:

Na index vrcholu zásobníku se můžeme dívat jako na revolver s kapacitou osmi ran. Při nabíjení se otáčí doleva (0–7–6–5-…), při střílení doprava. Současně se „posouvají“ i indexy pracovních registrů, což může být matoucí. Z tohoto důvodu programátoři buď používají matematický koprocesor tak, jakoby se jednalo o čistý zásobník, nebo naopak jakoby se jednalo o čip s osmi nezávislými registry (osobně jsem se to snažil kombinovat, ovšem bez zakreslení přesných stavů registrů je to složité).

18. Pomocný program pro převod FPU hodnot do jejich hexadecimální podoby

Hodnoty s plovoucí řádovou čárkou samozřejmě není nutné převádět do jejich bitové či hexadecimální podoby ručně. Pro zpětný převod FP hodnot, tedy hodnot reprezentovaných v systému plovoucí řádové čárky do hexadecimální 32bitové reprezentace je možné použít i následující jednoduchý program napsaný v céčku. Pokud při spuštění programu specifikujete na příkazové řádce FP hodnotu, například 0.5, vypíše se ihned její obraz v paměti, tj. to, jak je číslo interně reprezentováno (logiku programu lze v případě potřeby jednoduše i obrátit tak, aby převádět hexadecimální reprezentaci na FP hodnotu):

#include <stdio.h>
#include <stdlib.h>
 
union {
    float flt;
    int   hex;
} float_hex;
 
int main(int argc, char **argv)
{
    if (argc == 2) {
        float_hex.flt = atof(argv[1]);
        printf("%08x\n", float_hex.hex);
    }
    return 0;
}

Funkci tohoto prográmku si můžeme jednoduše odzkoušet:

gcc -o fp2hex fp2hex.c 
 
./fp2hex 0
00000000
 
./fp2hex 1
3f800000
 
./fp2hex -1
bf800000
 
./fp2hex 3.14
40490fdb

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/
137. A20 line
     https://en.wikipedia.org/wi­ki/A20_line
138. Extended memory
     https://en.wikipedia.org/wi­ki/Extended_memory#eXtended_Me­mory_Specification_(XMS)
139. Expanded memory
     https://en.wikipedia.org/wi­ki/Expanded_memory
140. Protected mode
     https://en.wikipedia.org/wi­ki/Protected_mode
141. Virtual 8086 mode
     https://en.wikipedia.org/wi­ki/Virtual_8086_mode
142. Unreal mode
     https://en.wikipedia.org/wi­ki/Unreal_mode
143. DOS memory management
     https://en.wikipedia.org/wi­ki/DOS_memory_management
144. Upper memory area
     https://en.wikipedia.org/wi­ki/Upper_memory_area
145. Removing the Mystery from SEGMENT : OFFSET Addressing
     https://thestarman.pcminis­try.com/asm/debug/Segments­.html
146. Segment descriptor
     https://en.wikipedia.org/wi­ki/Segment_descriptor
147. 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/qu­estions/45094696/when-using-a-32-bit-register-to-address-memory-in-the-real-mode-contents-of-the
148. A Brief History of Unreal Mode
     https://www.os2museum.com/wp/a-brief-history-of-unreal-mode/
149. Segment Limits
     https://wiki.osdev.org/Segment_Limits
150. How do 32 bit addresses in real mode work?
     https://forum.osdev.org/vi­ewtopic.php?t=30642
151. The LOADALL Instruction by Robert Collins
     https://www.rcollins.org/ar­ticles/loadall/tspec_a3_doc­.html
152. How do you put a 286 in Protected Mode?
     https://retrocomputing.stac­kexchange.com/questions/7683/how-do-you-put-a-286-in-protected-mode
153. Control register
     https://en.wikipedia.org/wi­ki/Control_register
154. CPU Registers x86
     https://wiki.osdev.org/CPU_Re­gisters_x86
155. x86 Assembly/Protected Mode
     https://en.wikibooks.org/wi­ki/X86_Assembly/Protected_Mo­de
156. MSW: Machine Status Word
     https://web.itu.edu.tr/kes­gin/mul06/intel/intel_msw­.html
157. 80×87 Floating Point Opcodes
     http://www.techhelpmanual.com/876–80×87_floating_point_opcodes.html
158. Page Translation
     https://pdos.csail.mit.edu/6­.828/2005/readings/i386/s05_02­.htm
159. 80386 Paging and Segmenation
     https://stackoverflow.com/qu­estions/38229741/80386-paging-and-segmenation
160. 80386 Memory Management
     https://tldp.org/LDP/khg/Hy­perNews/get/memory/80386mm­.html
161. DOSEMU
     http://www.dosemu.org/
162. Intel 80386, a revolutionary CPU
     https://www.xtof.info/intel80386.html
163. PAI Unit 3 Paging in 80386 Microporcessor
     https://www.slideshare.net/Kan­chanPatil34/pai-unit-3-paging-in-80386-microporcessor
164. 64 Terabytes of virtual memory for 32-bit x86 using segmentation: how?
     https://stackoverflow.com/qu­estions/5444984/64-terabytes-of-virtual-memory-for-32-bit-x86-using-segmentation-how
165. Pi in the Pentium: reverse-engineering the constants in its floating-point unit
     http://www.righto.com/2025/01/pentium-floating-point-ROM.html
166. Simply FPU
     http://www.website.masmfo­rum.com/tutorials/fptute/
167. Art of Assembly language programming: The 80×87 Floating Point Coprocessors
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–3.html
168. Art of Assembly language programming: The FPU Instruction Set
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–4.html
169. INTEL 80387 PROGRAMMER'S REFERENCE MANUAL
     http://www.ragestorm.net/dow­nloads/387intel.txt
170. x86 Instruction Set Reference: FLD
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₀.html
171. x86 Instruction Set Reference: FLD1/FLDL2T/FLDL2E/FLDPI/­FLDLG2/FLDLN2/FLDZ
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₁.html
172. X86 Assembly/Arithmetic
     https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
173. 8087 Numeric Data Processor
     https://www.eeeguide.com/8087-numeric-data-processor/
174. Data Types and Instruction Set of 8087 co-processor
     https://www.eeeguide.com/data-types-and-instruction-set-of-8087-co-processor/
175. 8087 instruction set and examples
     https://studylib.net/doc/5625221/8087-instruction-set-and-examples