Naučte se assembler

Základní pojmy

Na úvod bude dobré ujasnit si některé základní pojmy.

Mikroprocesor se skládá z jednoho (nebo více) integrovaných obvodů. Tohle označení se používalo hlavně v 70. a 80. letech 20. století, aby se odlišily nové mikroprocesory (většinou obvody vysoké a velmi vysoké integrace – LSI, VLSI) od starých procesorů, poskládaných z mnoha jednodušších obvodů. S masivním nástupem PC třídy 386 a vyšší se zase začalo používat slovo „procesor“. Slovo „mikroprocesor“ tak zůstává spojeno hlavně s osmibitovou érou.

Mikroprocesor většinou obsahuje nějakou řídicí jednotku, která vykonává program, sadu registrů, v nichž jsou uložena data, se kterými se pracuje, a nějakou jednotku, ve které se provádějí matematické operace.

Ve světě mikroprocesorů nejsou žádné příkazy známé z vyšších programovacích jazyků. PRINT tu nenajdete. Jediné, co procesor umí, je vzít z paměti číslo – operační (strojový) kód instrukce – a podle něj provést nějakou činnost, třeba přesunout hodnotu odněkud někam nebo sečíst dvě čísla. Jediné, čemu mikroprocesor rozumí, je tedy číslo. A protože hovoříme o osmibitových mikroprocesorech, je přirozené, že ta nejčastěji používaná čísla budou právě osmibitová, tedy v rozsahu 0 až 255, hexadecimálně 00h až FFh.

Platí tedy. že každý osmibitový procesor zná přesně 256 instrukcí? Ani náhodou! Některé jich znají mnohem míň (třeba procesor 8080), takže některé operační kódy nemají žádnou přiřazenou instrukci. Jiné naopak mají mnohem víc instrukcí (Z80) a řeší to tím, že některé instrukce mají operační kód vícebajtový.

Program se skládá z instrukcí, které procesor vykonává po řadě tak, jak jdou po sobě v paměti, s výjimkou skoků. Program je zapsaný třeba takto:

21h 55h 3Ah

Tyto tři bajty jsou procesorem 8080 interpretovány tak, že do registrů H a L uloží hodnoty 3Ah a 55h. U procesoru Z80 mají tato tři čísla stejný efekt (protože Z80 je s 8080 na úrovni strojového kódu kompatibilní). U procesoru 6502 mají zcela jiný význam – vezme se obsah registru X, k němu se přičte číslo 55h, výsledek se ořízne na osm bitů a dostaneme adresu. Z paměti na téhle adrese se vezme jeden bajt, z paměti na adrese o jedničku vyšší druhý bajt. Tyto dva bajty dají dohromady 16bitovou adresu v paměti, kam procesor sáhne pro číslo, a nakonec provede operaci AND mezi hodnotou v registru A a tímto číslem (výsledek uloží do registru A). No a pak následuje prázdná instrukce (3Ah).

Různé procesory mají tedy odlišné vnímání stejných kódů, což je důvod, proč nelze vzít program pro jeden z nich a spustit bez úprav na druhém.

Jazyk symbolických adres (JSA) slouží k tomu, aby si programátor nemusel pamatovat tyhle číselné kódy (což o to, většinou si je stejně pamatují), a aby u složitějších programů nemusel počítat adresy, tj. na jaké adrese v paměti je která instrukce. Proto zavádí jednak symbolická návěští (takže se zapisuje nikoli JUMP 1234h, ale třeba JUMP START), a jednak zavádí symbolická jména pro instrukce. Takže třeba u procesoru 8080 nemusí programátor zapisovat zmíněný skok jako kód C3h, ale symbolicky: „JMP“ (jako že jump, rozumíme si…)

Assembler je nástroj, který překládá program, zapsaný v těchto symbolických jménech, do konkrétních kódů jednotlivých instrukcí.

Co to znamená, když se řekne „Program je napsaný v assembleru“? Ve skutečnosti to, že program je napsaný v jazyku symbolických adres. Zkrátka se stalo, že se tomuhle jazyku začalo říkat „assembler“, i když správně je assembler vlastně ten překladač.

A když někdo řekne, že napsal program „ve strojáku“? Pravděpodobně ho napsal v tom symbolickém jazyce a přeložil assemblerem do strojového kódu. „Stroják“ je takové označení, které se taky přeneslo na jazyk symbolických adres. Ale mohlo se stát, že je dotyčný hardcore programátor a opravdu z hlavy nadiktoval instrukční kódy…

Teď jsme si vymezili základní pojmy, co dál? V zásadě se můžeme pustit do popisu procesoru a jeho instrukcí. Můžete se podívat na procesor, který vás zajímá, ale pokud nevíte, jaký vás zajímá, začněte od toho nejstaršího, kterému se budu věnovat, a tím je Intel 8080.

8080 – architektura

Než se podíváme na jednotlivé instrukce, ukážeme si, co v takovém procesoru 8080 vlastně je a jak to můžeme použít.

Procesor 8080 byl uveden na trh v roce 1974. Bohužel, trpěl několika nedostatky, z nichž snad největší bylo to, že výstupy procesoru snesly jen malé zatížení. Brzy přišla varianta 8080A, která byla naprosto totožná co do vývodů a instrukcí, ale měla posílené vývody a byla rychlejší. Když se dneska hovoří o mikroprocesoru 8080, má mluvčí na mysli nejčastěji právě „áčkovou“ variantu.

Mikroprocesor 8080 byl v jednom pouzdře DIL se 40 vývody.

Z těchto 40 vývodů bylo 16 pro adresovou sběrnici (A0-A15), 8 pro datovou (D0-D7), 4 piny sloužily k napájení (zem, +5V, +12V, -5V) a zbytek byly řídicí signály(RESET, INT, WR apod.)

Mikroprocesor pro svou činnost vyžadoval dva podpůrné obvody – 8224, který se staral o správné generování a fázování hodin, a 8228, který posiloval datovou sběrnici a zároveň se staral o generování řídicích signálů MEMR, MEMW, IOR, IOW a dalších. (MEMx obsluhovaly paměť, IOx vstupně-výstupní zařízení, R znamenalo čtení, W zápis).

Díky šestnácti adresním linkám může mikroprocesor adresovat paměť o kapacitě 64kB (2^16). Z paměti může přenést osmibitové slovo (tedy hodnotu 0-255).

V procesoru se nachází několik základních bloků:

§  Časovací a řídicí obvody se starají o správnou synchronizaci ostatních částí, o správné vyhodnocení řídicích signálů, co přicházejí zvenčí, a o posílání stavových informací ven.

§  Registr instrukcí drží instrukční kód, načtený z paměti, dokud jej nezpracuje dekodér.

§  Dekodér instrukcí rozloží instrukční kód na posloupnost základních operací, o jejichž provedení se postará řadič.

§  ALU, neboli aritmeticko-logická jednotka se stará o základní matematické operace (sčítání, odčítání, AND, OR, XOR) s osmibitovými čísly.

§  Akumulátor (též registr A) je osmibitový pracovní registr procesoru. S ním se provádí naprostá většina operací, zejména aritmetické, logické či porovnávací.

§  Pracovní registry B, C, D, E, H a L jsou registry, které může programátor využít pro dočasné uložení hodnot. Jsou opět osmibitové. Některé instrukce ale dokážou pracovat s tzv. registrovým párem – v takovém případě se berou registry B a C, resp. D a E / H a L jako jeden šestnáctibitový registr. Pár registrů H a L je často používán pro uložení adresy při nepřímém adresování – např. „do akumulátoru se přesouvá hodnota, která je uložena v paměti na adrese, uložené v registrech HL“.

§  Ukazatel zásobníku, zvaný též registr SP, je šestnáctibitový registr, v němž je uložena adresa tzv. zásobníku. Více si o jeho funkci řekneme v kapitole o podprogramech.

§  Programový čítač (registr PC) je šěstnáctibitový registr, v němž je uložena adresa, z níž procesor čte instrukci. Po přečtení instrukce se zvýší o 1, 2 nebo 3, takže ukazuje na další instrukci. (Záleží na délce instrukce)

§  Příznakový registr F není pro většinu instrukcí samostatně přístupný. Obsahuje několik tzv. příznakových bitů, které udržují informaci o tom, jestli poslední výsledek byl 0, jestli byl záporný, jestli při výpočtu přetekla hodnota přes hranici 255 (nebo pod 0) atd. Podle těchto bitů pak může procesor vykonat tzv. podmíněné instrukce.

Krom těchto částí obsahuje procesor i další skryté registry (W, Z, ACT), ke kterým ale nemá programátor přístup. Mikroprocesor je používá pro ukládání mezivýsledků dle své potřeby.

Po zapnutí napájení nebo po signálu RESET je procesor uveden do základního stavu. Je zakázáno přerušení (k pojmu přerušení se dostaneme později) a do registru PC (šestnáctibitový ukazatel na instrukci) je uložena nula. Ostatní registry mají obsah takový, jaký měly před RESETem (po zapnutí napájení tedy náhodný).

Hodiny běží… Co se v procesoru děje?

Probíhá první strojový cyklus (zvaný M1). V tomto cyklu procesor pošle na adresovou sběrnici obsah registru PC (teď to je 0), zvýší obsah tohoto registru o 1 a pošle požadavek „čtení z paměti“ (MEMR). Systém okolo by se měl postarat, aby na tento požadavek odpověděla paměť a poslala po datové sběrnici obsah na dané adrese. Mikroprocesor si tento obsah přečte, uloží do registru instrukcí, dekóduje a provede požadovanou činnost. Někdy není potřeba žádný dodatečný čas, jindy se například zapisuje do paměti nebo z ní čte, takže procesor zařadí některé z cyklů M2, M3, M4, M5. Po dokončení instrukce se celý proces opakuje.

V případě, že instrukce vyžaduje nějaký parametr, následují cykly čtení z paměti. Instrukce může jako parametr požadovat 1 nebo 2 bajty. Ty jsou načteny z adresy PC+1 a PC+2. PC je zvýšen o 2 nebo 3. Instrukce je pak provedena (což si opět může vyžádat nějaké strojové cykly) a po jejím dokončení se celý proces zase opakuje.

Strojový cyklus M1 se skládá ze čtyř nebo pěti taktů systémových hodin. Protože každá instrukce obsahuje vždy cyklus M1, v němž je načtena a dekódována, tak je jasné, že nejrychlejší instrukce zabere čtyři hodinové cykly (zapisuje se jako 4T). Pokud běží hodiny na frekvenci 2MHz, tak budou ty nejrychlejší instrukce prováděny s frekvencí 500kHz (tj. každá bude trvat 2 mikrosekundy). Nejpomalejší instrukce zaberou 18 taktů (18T). Informace o tom, jak je která instrukce „dlouhá“ (tj. kolik T trvá procesoru, než ji zpracuje) je důležitá ve chvíli, kdy je třeba optimalizovat kód a zrychlit jej.

Základy assembleru

Ano, já vím, terminologicky to není správné označení, ale mí čtenáři mu rozumí. Půjde o Jazyk symbolických adres, všeobecně (a nesprávně) nazývaný assembler.

Procesor, jak jsme si už řekli, zpracovává instrukce tak, že čte z paměti jejich strojový kód po bajtech, ty dekóduje a podle nich provádí požadované činnosti.Zápis programů v číselných hodnotách by byl velmi nepohodlný, proto se používá zápis pomocí mnemotechnických názvů instrukcí. Takovému zápisu se říká „jazyk symbolických adres“, nebo (nesprávně, ale všeobecně srozumitelně) „zápis v assembleru“ (anglicky assembly language).

Definice JSA na Wikipedii.

Program se v JSA zapisuje jako v jiných jazycích do textového souboru po řádcích. Řádky mají přesně definovaný formát a skládají se z následujících prvků:

1.     Návěští: řetězec znaků [A-Z, 0-9, podtržítko], který nezačíná číslicí. Některé překladače rozlišují jen prvních 6 znaků, jiné prvních 8, další pak všechny. Návěští je zakončeno dvojtečkou.

2.     Instrukce: mnemotechnická zkratka instrukce, popřípadě pseudoinstrukce (direktivy)

3.     Parametry: Některé instrukce a direktivy vyžadují další údaje, se kterými musí instrukce pracovat. Zapisují se za mnemotechnické označení instrukce, od které se oddělí mezerou (nebo mezerami). Pokud je parametrů víc, oddělují se od sebe čárkami.

4.     Poznámka: Cokoli, co si potřebujete poznamenat. Na začátku je znak středník (;), vše, co je za tímto znakem, překladač ignoruje.

Ukažme si různé typy řádků.

§  Prázdný řádek překladač prostě ignoruje

§  Řádek, kde je jen poznámka. Pokud je prvním znakem na řádku (mezery nepočítáme) znak středník, bere se zbytek řádku jako poznámka a překladač jej ignoruje.

§  Řádek s instrukcí: Na řádku je uvedena existující (pseudo)instrukce, popřípadě její parametry, má-li nějaké. Překladač ji přeloží na odpovídající operační kód. Za parametry může být ještě poznámka, kterou překladač ignoruje

§  Řádek s návěštím: Libovolný typ výše uvedených řádků může ještě začínat návěštím, tj. řetězcem ukončeným dvojtečkou. V takovém případě překladač přiřadí tomuto řetězci adresu, která odpovídá internímu počítadlu adres. (K tomu se ještě vrátím.)

Podívejme se na ukázku kódu:

V tomto kódu najdete řádek s komentářem (1), prázdný řádek (3), řádky s instrukcemi i řádky s návěštím.

Použil jsem jen jednu instrukci, totiž instrukci NOP, kterou znají všechny tři procesory a její význam je prostý: Nedělej nic. Možná se vám zdá zbytečné mít instrukci, která nedělá nic, ale ona se docela dobře hodí – když potřebujete někde „chvilku počkat“, nebo když si chcete někde nechat místo pro budoucí změnu. U procesorů 8080 / Z80 je její kód 0, u procesoru 6502 je to 0EAh.

Instrukce „.org“ není instrukcí v pravém slova smyslu. Nemá totiž žádný operační kód. Pouze říká překladači: Teď se chovej tak a tak. Patří tedy mezi pseudoinstrukce (nebo taky „direktivy“). Org je zkratka pro „origin“, tedy počátek. Tady říká překladači: Ber to tak, že tady, jak jsem já, bude nějaká konkrétní adresa, a následující instrukce tedy ukládej od té adresy dál.

Pseudoinstrukce .org má jeden parametr – totiž tu adresu. Tady je zapsaná v hexadecimální podobě.

jak lze zapsat konstanty v assembleru?

§  Hexadecimální zápis

§  Pomocí číslic 0-9 a znaků A-F. Číslo začíná vždycky číslicí a je ukončeno znakem H (h). Takže: 1234h, 00AAH, 23beh, 0cfh, 18H, …

§  Pomocí číslic 0-9 a znaků A-F, před kterým je znak $. Takže: $1234, $00AA, $23be, $cf, $18, …

§  Některé překladače umožňují i zápis v „céčkové“ syntaxi „0x…“

§  Binární zápis

§  Řetězec znaků 0,1 ukončený písmenem „b“

§  Řetězec znaků 0,1, před kterým je znak „%“

§  Desítkové číslo

§  Zapsáno tak, jak jsme zvyklí.

§  Znaková konstanta

§  Znak zapsaný v apostrofech nebo uvozovkách. Hodnotou je ASCII kód daného znaku. Např. „@“ = 64 = 40h

Tady je na místě připomenout, že konkrétní syntaxe jednotlivých překladačů se může lišit. V dalším popisu budu vycházet z tvaru, jaký jsem implementoval v překladači ASM80. Totéž platí i pro pseudoinstrukce – někde je správný zápis „org“, u jiného překladače je to důsledně „.org“ s tečkou. ASM80 povoluje oba tvary. Původní assemblery braly zápis bez tečky.

listing

Když si vezmete výše zapsaný kód a zkusíte ho přeložit překladačem – např. výše zmíněným ASM80 – získáte na výstupu jednak binární podobu (která nebude moc zajímavá), jednak takzvaný listing, což je výpis programu spolu s adresami a instrukčními kódy.

Každý řádek začíná adresou, na jaké je daná instrukce uložena. Vidíte, že na prvním řádku ještě překladač neví, kde chceme program mít, a tak počítá s tím, že bude uložený od adresy 0. Na druhém řádku pseudoinstrukcí .org říkáme, že program bude v paměti uložen od adresy 0100h. Překladač si proto nastaví interní počítadlo adres (_PC) na hodnotu 0100h. Třetí řádek je „prázdný řádek s návěštím“. To znamená, že do tabulky návěští je zařazeno návěští se jménem ZACATEK a je mu přiřazena hodnota interního počítadla adres, tedy 0100h.

Čtvrtý řádek obsahuje konečně nějakou reálnou instrukci. Je to instrukce NOP, je přeložena na operační kód (00) a ten bude uložen na adrese 0100h. Počítadlo se posune na následující adresu, tedy 0101h.

Pátý řádek: NOP, kód je zase 00, je uložen na adrese 0101h a počítadlo se posouvá…

Šestý řádek: NOP, kód je zase 00, je uložen na adrese 0102h a počítadlo se posouvá…

Na sedmém řádku je návěští NAVEST. Je mu tedy přiřazena hodnota interního počítadla adres (0103h). Na tomtéž řádku je i instrukce. Její operační kód je uložen na tuto adresu a pokračujeme dál…

Na samotném konci listingu vidíte výpis všech návěští. _PC je interní počítadlo adres (které skončilo na hodnotě 0104h), no a návěští ZACATEK a NAVEST mají ty hodnoty, jaké jsme si popsali výše.

Základy jsou tedy jasné, pojďme na skutečné programování v assembleru!

8080 – první program

Napíšeme si první program. Nekecám, opravdu první program v assembleru pro procesor 8080!

Nebude to Hello world, bude to něco sofistikovanějšího. Sečteme dvě čísla. Třeba 18H a 23H. (Výsledek je 03BH, kdo nevěří, ať tam běží.) Nebojte se toho, že nezačínám od základů, že ještě žádnou instrukci neznáte (ne, znáte jednu, z minulé lekce víte o NOP) ani že neřeknu hned všechno (třeba zamlčím existenci „registru“ M). Jen si odskočíme, abyste viděli, jak se v assembleru pracuje, a už v příští lekci to budeme brát systematicky instrukci po instrukci…

Ale teď: Jak sečíst dvě čísla v assembleru? Asi už tušíte, že to nebude prosté jako napsat „18+23“. Procesor 8080 totiž nic takového jako „sečti dvě čísla, která ti sem napíšu“ neumí. Co umí?

Umí sečíst dvě čísla, to je v pořádku. K sečtení slouží instrukce ADD, se kterou se seznámíme v dalších lekcích. ADD má jeden parametr, a tím je jméno registru. Vzpomeňte si na kapitolu o architektuře 8080: máme k dispozici registry B, C, D, E, H, L a akumulátor A. Instrukce ADD má symbolický tvar „ADD r“ (kde „r“ je právě to jméno registru) a její funkce je následující: Vezme obsah registru A, přičte k němu obsah zadaného registru, a výsledek uloží zase do A. Nějak takhle:

Postup bude tedy následující: Do jednoho registru si uložíme první číslo, tedy 18H, do druhého registru druhé číslo (23H), a pak je pomocí instrukce ADD sečteme. Protože ADD vyžaduje, aby jeden ze sčítanců byl v registru A, ušetříme si práci tím, že jedno z čísel umístíme rovnou do A, druhé třeba do B.

Jak do registrů nahrajeme nějaké číslo? Použijeme k tomu instrukci MVI (Move Immediate). Tato instrukce má dva parametry – první je jméno registru, druhý je hodnota 0-255, tedy 1 bajt. Symbolicky zapsáno je to „MVI r, n8“ (n8 se označuje osmibitové číslo). Všimněte si, že pořadí parametrů je podobné jako ve vyšších jazycích, tedy vlevo je to, KAM se ukládá, vpravo CO se tam má uložit. V našem případě použijeme dvojici instrukcí „MVI A, 23H“ a „MVI B, 18H“.

Celý program bude vypadat takto:

Co se tam děje? Nejprve říkáme překladači, ať si nastaví adresu 0, od té adresy se budou ukládat instrukce do paměti. Pak je instrukce, která do registru A uloží hodnotu 23h, pak do registru B uložíme 18h, a pak vykonáme ADD B, což je, jak už víme, ekvivalent „A = A + B“.

Ukažme si ještě listing:

Instrukce MVI zabírá vždy dva bajty. První bajt je kód instrukce (3Eh = MVI A; 06h = MVI B), druhý bajt je hodnota, která se má do registru nahrát.

Tak, to by bylo. A teď otázka nejdůležitější: Bude to fungovat? Bude. V tuhle chvíli vám nezbývá nic jiného, než mi věřit. Anebo si to vyzkoušet. Buď použijte svůj oblíbený assembler, spusťte si kód na svém počítači (třeba PMI-80) – no a nebo využijte ASM80, kde si můžete kód napsat, přeložit a odladit v emulátoru, a to všechno přímo v prohlížeči (tedy, pokud máte aspoň trošku modernější prohlížeč)! V okénku, co je pod tímto textem, máte k dispozici editor, překladač i debugger, takže si můžete výše zmíněný kód vyzkoušet. Napište ho do levého editoru (on už tam je předvyplněný…) a kliknutím na COMPILE ho přeložíte. V pravém editoru se ukáže listing. Funkčnost můžete otestovat kliknutím na Emulator – levý editor zmizí a místo něj se objeví okno s výpisem paměti, s výpisem jednotlivých registrů a s tlačítky Single step, 50 steps, Animate a Stop. Po vstupu do emulátoru je PC nastaven na 0000, procesor je připraven na první instrukci. Kliknutím na Single step ji provedete. Všimněte si, že se v registru A objevilo 23 a kurzor se posunul na další instrukci. Opět klikněte na Single Step, v registru B se objeví 18, no a po dalším kliknutí na Single step se provede i ta sčítací instrukce. Takto si můžete krokovat svoje programy a dívat se, jestli dělají to, co dělat mají.

Náš program nic víc neudělá. Když si ho odkrokujete, dostanete výsledek v registru A a pak se nestane nic.

Ale co, Řím taky nepostavili za den!

No related posts.

Instrukce 8080 – adresní módy a registry

Jak instrukce ví, kde má vzít data, se kterými pracuje?

Některé instrukce (jako už zmíněný NOP) nevyžadují žádné parametry a nepracují s žádnými daty. Tam je to jasné. Ovšem většina instrukcí něco dělá, to znamená, že potřebuje odněkud vzít nějaké údaje, někam je uložit atd. Procesor 8080 má čtyři různé způsoby, jak říct, kde se data nacházejí.

přímý operand

Tímto způsobem zapíšeme přímo hodnotu do kódu a procesor ji použije. S přímým operandem pracuje např. instrukce MVI, kterou jsme si ukázali v minulé kapitole, Součástí instrukce je přímo hodnota, která je použita.

přímé adresování

Je podobné předchozímu. I v tomto případě je součástí instrukce hodnota, která ale není použita tak, jak je, ale je brána jako adresa (v paměti nebo vstupně-výstupní brány). Například instrukce „LDA 554Ah“ používá právě tento typ adresování. Procesor udělá to, že hodnotu 554Ah vezme jako adresu místa v paměti, přečte z něj jeden bajt a ten uloží do registru A.

adresování registrem

Součástí instrukce je jméno registru, registrového páru nebo dvojice registrů, se kterými se operace provádí.

nepřímé adresování registrem

Instrukce bere hodnotu v dvojici registrů (BC, DE, HL) nebo v registru SP jako adresu do paměti. Pracuje pak s obsahem na této adrese.

Některé instrukce pracují s tzv. „implicitním operandem“, což znamená, že operand (jeden z operandů) je daný už samotnou instrukcí. Například zmíněná instrukce ADD používá dva operandy – jeden je vždy A a druhý je určen parametrem.

registry

U osmibitových instrukcí můžeme použít libovolný osmibitový registr – tedy A (akumulátor), B, C, D, E, H, L a M.

Moment! Registr M? Nikde jsem se o něm nezmínil… Není to nějaký renonc?

Není. „Registr M“ (memory) je ve skutečnosti buňka v paměti na adrese, která je uložena v registrech H a L. Pokud je v registru H hodnota 12h a v registru L hodnota 34h, bude instrukce, která pracuje s „registrem M“, pracovat ve skutečnosti s obsahem paměti na adrese 1234h. Instrukce ADD M přičte k obsahu registru A hodnotu z paměti na adrese 1234h.

Všimněte si, že nelze přímo přistupovat k registru F. Ono to většinou není k ničemu dobré, ale kdybyste opravdu potřebovali znát jeho hodnotu, dá se to obejít takovým trikem, který si popíšeme později.

Pokud instrukce pracuje s šestnáctibitovou hodnotou, využívá šestnáctibitový registr SP nebo dvojice registrů B, D, H. „Dvojregistr“ B  jsou vlastně registry B a C, v B je vyšší bajt, v C nižší. Obdobně pro D a H. Instrukce pro práci se zásobníkem používají „šestnáctibitový registr“ PSW, což je ve skutečnosti dvojice registrů A a F (A vyšší byte, F nižší).

malý indián

Procesory Intel, Zilog Z80 i 6502 používají zápis vícebytových čísel ve formátu „Little Endian“. Znamená to, že na nižší adrese je méně významná část čísla. Příklad: Na adresu 0100h uložíme naši obligátní hodnotu 1234h. Paměť je organizovaná po bajtech, hodnota je dvoubajtová (16 bitů), jak to tedy uložit? Použijeme dvě buňky paměti, 0100h a 0101h. Na tu nižší přijde nižší část čísla (34h), na tu vyšší zase vyšší část (12h). V paměti to tedy bude vypadat nějak takto:

0100h: 34h
0101h: 12h

Některé procesory (z těch známějších především procesory od Motoroly) používají opačný způsob („Big Endian“), kdy se části čísla zapisují do paměti od nejvýznamnějšího bajtu.

Instrukce 8080 – přesuny dat

První skupina instrukcí, kterou si probereme, přesouvá data. Z registrů, do registrů, i z paměti a do paměti…

Až budete psát programy v assembleru, zjistíte, že nejvíc kódu nezabírají nějaké hyper super složité výpočty, ale přesouvání dat odněkud někam. V podstatě většina činností, které mikroprocesorový systém navenek dělá, je z valné části přesouvání dat. Samotného počítání je minimum. Takže je jen logické, že začneme právě u těchto instrukcí.

mov

Univerzální instrukce pro kopírování obsahu z jednoho registru do druhého. Instrukce má dva operandy – názvy osmibitových registrů (z minulého dílu víme, že to jsou A, B, C, D, E, H, L a M). Jako první se uvádí cílový, jako druhý zdrojový. MOV A,B tedy vezme obsah registru B a zkopíruje ho do registru A. MOV A,C zkopíruje obsah z registru C do registru A. MOV C,A přesně naopak – z registru A do registru C.

Ptáte se, kolik je kombinací? No všechny dostupné – tedy 8 x 8 = 64. Čímž neříkám, že jsou všechny smysluplné či funkční. Instrukce MOV A,A je samosebou platná, zkopíruje obsah z registru A do registru A, ale upřímně: k čemu to je?

Znovu připomínám, že M je „pseudoregistr“, který ve skutečnosti odkazuje na místo v paměti s adresou, která je uložená v dvojici registrů H, L. Takže MOV A,M znamená „vezmi obsah z paměti na adrese, která je v registrech H,L, a zkopíruj ho do registru A“. MOV M,E znamená „vezmi obsah registru E a zkopíruj ho do paměti na adresu, tkerá je v registrech H,L“. No a MOV M,M – to je výjimka. Taková instrukce neexistuje. Její operační kód zaujímá instrukce HLT, která zastaví procesor.

mvi

Tato instrukce vloží do osmibitového registru přímo zadanou hodnotu.

lxi

Tato instrukce vloží do registrového páru B, D, H nebo registru SP přímo zadanou šestnáctibitovou hodnotu.

lda

Instrukce má jeden parametr – šestnáctibitovou adresu. Obsah paměti na téhle adrese zkopíruje do registru A

sta

Protipól předchozí instrukce – ukládá hodnotu z registru A do paměti na adresu zadanou jako operand.

A nyní si prosvištime nektera sloviška a cele fěty – pardon, zkusíme si, jak tyhle instrukce pracují. Opět k tomu použijeme interaktivní techniku – assembler ASM80.

Kód přeložte a spusťte emulaci. První instrukce je MVI A, 10. Po provedení prvního kroku bude tedy v registru A hodnota… aha! Je tam 0Ah. Emulátor totiž ukazuje všechny hodnoty hexadecimálně, zatímco v kódu je zapsaná konstanta 10, bez H na konci, takže je to tedy desítková hodnota, a 10 desítkově je v šestnáctkové soustavě 0A. (A nestěžujte si, různé způsoby zápisu konstant jsme už brali!)

Takže tedy znovu: První instrukce uloží do registru A hodnotu 0Ah (=10), druhá instrukce uloží do registru B hodnotu 14h (=20). Třetí instrukce je LXI H, číslo – mrkněte se o kousek výš… jasně! Tahle instrukce uloží zadané číslo do dvojice registrů HL. Tady je to 0040h, takže do H půjde vyšší (00) a do L nižší (40h) část čísla.

Na dalším řádku je instrukce MOV M,A. Z toho, co o ní víme, by se mělo stát následující: Obsah registru A (což je teď těch 0Ah) se zkopíruje do paměti na adresu, která je uložená v registrech HL. Tak schválně – v registrech HL je uložena hodnota 0040h, takže by se v paměti na adrese 0040h měla objevit hodnota 0Ah. Zkuste si sami – vidíte, že vlevo nahoře, v oblasti nadepsané MEMORY, se na adrese 0040h objeví právě ta hodnota 0Ah.

Bystřejší si všimli, že od adresy 0 jsou v paměti nějaká čísla. Ti, co jsou ještě bystřejší, už vědí: To je přeci ten náš program! A právě do té oblasti sáhne další instrukce – LDA 0003h vezme obsah paměti na adrese 0003h, což je zrovna shodou okolností číslo 14h (které je součástí instrukce MVI B, 20) a uloží ho do registru A.

Poslední instrukce pak uloží obsah registru A na adresu 0041h, takže od adresy 0040h budete mít vedle sebe hezky 0Ah a 14h. Máte? Skvělé, pojďme na další instrukce!

ldax

Tak jako LDA vezme hodnotu z paměti na adrese, kterou mu zadáme, a uloží ji do A, tak i LDAX vezme hodnotu z paměti a uloží ji do A. Adresu, se kterou se bude pracovat, najde v registrovém páru B nebo D (tedy v registrech B, C, resp. D, E).

stax

Jako má LDA svoje STA, tak má LDAX svůj STAX. Funguje stejně jako LDAX, jen přenos dat probíhá v opačném směru.

lhld

Tahle instrukce opět pracuje s dvojicí bajtů. Jako parametr dostane adresu a vykoná následující: Do registru L zkopíruje hodnotu z paměti na dané adrese a do registru H zkopíruje hodnotu z paměti na adrese o 1 vyšší.

shld

Už to tak je. Instrukce Lněco mají svou obdobu v podobě Sněco. Tam, kde L z paměti čte (load), tam S do paměti zapisuje (store). Takže SHLD uloží obsah registru L na zadanou adresu, obsah registru H na adresu o 1 vyšší.

Všimněte si, že LHLD i SHLD dodržují pravidlo „malého indiána“ – na nižší adresu jde méně významný bajt.

xchg

Poslední instrukce pro přesun dat je tak trošku výjimka. Nemá žádné operandy – to, s čím pracuje, je dáno implicitně (jsou to dvojregistry D a H). A na rozdíl od předchozích instrukcí, které kopírovaly hodnoty, tato instrukce je vyměňuje. XCHG vymění obsah registrů D a E za obsah registrů H a L. Tedy to, co bylo v D, bude teď v H – a naopak. Kdybychom udělali třeba MOV H,D a MOV L,E, dosáhli bychom něčeho jiného obsah registrů D a E by se nevyměnil, ale ZKOPÍROVAL, takže by bylo v D totéž co v H a v E totéž co v L.

Pokud chceme vyměnit údaje ve dvou registrech, musíme použít pomocný registr. Například výměnu obsahu registrů B a C zařídíme takto:

Tedy přes registr A. Jeho původní hodnotu samozřejmě ztratíme…

A opět drobná ukázka. Až si pohrajete, můžete si zkusit jedno cvičení. První samostatný program. Poslyšte zadání, je jednoduché: Program prohodí obsah registrů BC a HL.

                                                                            No related posts.

8080 – příznaky a zásobník

Procesor potřebuje vědět, jak dopadla ta která instrukce, a občas si potřebuje nějaká data odložit na později.

O registru F jsem se už zmiňoval. Je to takový lehce mystický registr, do kterého se nedá přímo zapisovat a ze kterého se nedá přímo číst. Psal jsem, že v něm jsou uložené takzvané příznaky. Co to je?

Některé instrukce, převážně ty, co něco počítají, mohou dát najevo, že výsledek je v určitém formátu. Například že je nulový, záporný, jakou má paritu, nebo že při výpočtu přetekl výsledek z rozsahu 0-255. A přesně tyto informace ukládá jako příznakové bity do registru F.

U procesoru 8080 je příznakových bitů 5 a jsou v registru uloženy takto:

§  S (sign) informuje o znaménku výsledku. Je-li výsledek kladný, je to 0, je-li výsledek záporný, je to 1

§  Z (zero) je roven 1 v případě, že výsledek je nula. Pokud je nenulový, je Z = 0

§  AC (auxiliary carry) je roven 1, pokud při operaci došlo k přenosu přes polovinu bajtu (mezi nižší a vyšší čtveřicí)

§  P (parity) je nastaven vždy tak, aby doplnil počet jedniček ve výsledku na lichý (tedy 0, je-li lichý, 1, je-li sudý) – viz též paritní bit.

§  CY (carry) je 1, pokud dojde k přenosu z nejvyššího bitu.

Termín „přenos“ je možná nejasný, pojďme si ho upřesnit. Co se stane, když budu sčítat čísla 0FAh a 0Ah (250 a 10) v osmibitovém registru? Výsledek je 260, hexadecimálně 104h – a to je číslo, které má devět bitů. Devátý (nejvyšší) bit se do registru nevejde, tam zůstanou jen bity 0-7 (tedy osm bitů). Pokud taková situace nastane, je příznak CY nastaven na jedničku.

Tento příznak je velmi užitečný, pokud sčítáte vícebajtová čísla. Sečtete nejprve čísla na nižších řádech, a pokud je náhodou větší než možný rozsah, přenesete sijedničku do vyššího řádu.

Tentýž příznak funguje i pro odčítání – zde zase funguje jako označení „výpůjčky“ do nejvyššího řádu v případě, že výsledek je menší než 0. Když od čísla 04h odečteme číslo 05h, bude výsledek 0FFh (nezapomeňte, že hodnoty jdou za sebou a po nule je 0FFh). Příznak CY bude nastaven („půjčili“ jsme si jedničku), příznak S bude nastaven (výsledek je záporný).

Ve skutečnosti je -1 a 255 jedno a totéž číslo a je jen na nás, jestli se na něj díváme jako na číslo se znaménkem, nebo na číslo bez znaménka. -2 je 254, -3 je 253 atd. Pokud chceme v binární soustavě převést číslo na jeho zápornou hodnotu, uděláme bitovou negaci (zaměníme 0 za 1 a opačně) a přičteme jedničku (procesor na to samosebou má vhodnou instrukci).

A k čemu jsou příznaky dobré? Jednak pomáhají s výpočty, a jednak se můžete podle výsledků rozhodovat a provádět podmíněné skoky a volání podprogramů.

zásobník

Občas procesor potřebuje, jak jsem už psal, nějaká data „odložit“ na později. Ať už to jsou data, co si potřebuje uložit programátor, nebo třeba adresa, kam se má program vrátit z podprogramu. Používá k tomu strukturu zvanou zásobník (stack). Stack je struktura typu LIFO (Last In – First Out, tedy co se poslední uloží, to se první vrátí). Implementace zásobníku je jednoduchá: V paměti si vyhradíte oblast, a adresu jejího konce +1 uložíte do registru SP (Stack Pointer). Zásobník je připravený.

Do zásobníku se vždy ukládají dva bajty, tedy buď adresa, nebo celý registrový pár. Pokud na zásobník uložíme pár HL, stane se toto: Procesor sníží SP o 1, na tuto adresu uloží obsah registru H, pak zase sníží SP o 1 a na tuto adresu uloží obsah registru L. Teď uložíme třeba pár BC: Procesor sníží SP o 1, na tuto adresu uloží obsah registru B, pak zase sníží SP o 1 a na tuto adresu uloží obsah registru C.

Když teď vyzvedneme hodnotu ze zásobníku – třeba do registrů DE – procesor vezme obsah z adresy SP, uloží ho do registru E, SP zvýší o 1, vezme obsah z adresy SP, uloží ho do registru D a opět zvýší SP o 1. SP teď ukazuje na předchozí položku a v DE máme tu poslední uloženou. Což byla, shodou okolností, zrovna hodnota z registrů B a C – nikde není psáno, že se musí údaje vybrat do téhož registru, z jakého byly uloženy.

Zásobník se tedy posouvá od vyšších adres k nižším. Proto se umisťuje na konec RAM, aby měl dost prostoru kam růst. Což s sebou nese riziko, že pokud uložíte do zásobníku příliš mnoho hodnot, klesne SP až tak, že další uložená data můžou přepsat váš program (tomuto stavu se říká přetečení zásobníku, stack overflow). Pokud umístíte zásobník POD program, může se zase stát, že poklesne až třeba do oblasti, kde je ROM. Oba stavy jsou chybné, znamenají téměř stoprocentně pád programu a většinou nastávají, když se program dostane do nekonečné smyčky, ve které se odskakuje nebo ukládá.

push a pop

K uložení obsahu registrů do zásobníku slouží instrukce PUSH s jedním parametrem, a tím je jméno dvojice registrů (B, D, H), nebo „PSW“ – o kterém jsem se už zmiňoval. PSW (Program Status Word) je dvojice registrů A a F. Pro vybrání hodnot ze zásobníku slouží instrukce POP (a stejné parametry). Pojďme si zaexperimentovat: nastavíme si zásobník do paměti a budeme do něj ukládat a zase vybírat data.

Všimněte si nejprve toho, jak se do paměti ukládají data, když se vykonává instrukce PUSH. Později, při načítání zpět, je načítáme v jiném pořadí, takže registry nemají původní obsah.

Na konci minulé lekce jsem zadal úkol: vymyslet způsob, jak prohodit obsah registrových párů BC a HL. Předpokládám, že jste napsali něco takového:

Což je správně, ale přijdeme tím o obsah, který je v registru A. Pokud nám to nevadí, není co řešit. Ale pokud by nám to vadilo, dáme na začátek PUSH PSW a na konec POP PSW. Samozřejmě, spoléháme na to, že zásobník je správně nastavený, ale vzhledem k tomu, jak často je používaný, tak je to jedna z prvních věcí, co slušný programátor udělá.

No a s informacemi z této lekce můžete stejné zadání vyřešit třeba takto:

sphl

Tato instrukce naplní registr SP obsahem dvojice registrů HL. Tedy SP = HL. Ptáte se, jak se zařídí opak, tedy jak zjistíte hodnotu registru SP a uložíte ji do HL? Tipujete instrukci HLSP? Ne, žádná taková není. Musíte použít konstrukci LXI H,0 a DAD SP (o instrukci DAD si řekneme víc v další lekci).

xthl

Další instrukce, která vyměňuje hodnoty dvojic registrů. XTHL vymění hodnotu dvojice registrů HL s „poslední uloženou hodnotou na zásobníku“. Tedy: poslední hodnota, uložená na zásobníku, se ocitne v HL, a hodnota HL bude poslední hodnota na zásobníku.

Instrukce 8080 – aritmetika

Je to počítač, ne? Tak to má taky počítat!

Procesor samosebou není živ jen přesouváním dat tam a zpátky. Občas taky musí něco spočítat. K tomu mu slouží aritmetické instrukce pro sčítání, odčítání a porovnání. (Kde je násobení, dělení a hyperbolický sinus? Dozvíte se později!)

add

Instrukce ADD r vezme obsah v osmibitovém registru r (tedy A, B, C, D, E, H, L nebo M, což je ve skutečnosti obsah paměti, ale to už jsem psal asi pětkrát…) a přičte ho k registru A. Výsledek sčítání uloží do registru A. Pokud vám připadá, že se registr A používá nějak často, tak se vám to nezdá, je to opravdu tak, a protože se k němu vztahují skoro všechny aritmetické i logické instrukce, tak se mu říká „akumulátor“.

Po sčítání nastaví patřičně příznaky S, Z, AC, P a CY – viz popis funkce příznaků v minulé lekci.

Pojďme se podívat na pár příkladů sčítání a toho, jak ovlivní příznaky. Všechna čísla budou hexadecimálně.

se znaménkem…?

Jak to vlastně je, když chceme použít místo čísel bez znaménka (0-255) čísla se znaménkem (-128 až 127)? Kde to dáme procesoru najevo? Odpověď zní: Nikde! Procesoru to je úplně jedno. Vezměme si poslední řádek z předchozí tabulky. Pokud se bude jednat o čísla bez znaménka, tak sčítáme hodnotu 240 (F0h) a 5. To je dohromady 245, tedy hexadecimálně F5h. Když je budeme vnímat jako čísla se znaménkem, tak sčítáme -16 (F0h) a +5. Výsledek je -11, což je hexadecimálně F5h.

Předposlední řádek je podobný: při sčítání bez znaménka je FFh+01h=100h, což se do osmi bitů nevejde, máme tedy výsledek 00 a nastavený přenos (1). Pokud sčítáme se znaménkem, sčítáme -1 (FFh) a +1 a výsledek je – opět nula!

To, jestli pracujeme s čísly se znaménkem nebo bez znaménka, si musíme určit coby programátoři sami. Procesor je zpracovává stále stejně a je jen na nás, jak je interpretujeme. Jen je důležité je interpretovat vždy stejně.

adi

Často potřebujeme přičíst nějakou předem známou konstantu. Pomocí ADD bychom si ji museli nejprve uložit do některého registru, a ten pak přičíst. Naštěstí to jde rychleji, pomocí jedné instrukce ADI. Ta má jediný parametr, a tím je osmibitová konstanta. Tu přičte k registru A. Zbytek, tedy nastavování příznaků apod., platí stejně jako u instrukce ADD.

adc

Funguje stejně jako instrukce ADD, ale k výsledku přičte ještě hodnotu příznaku CY. Hodí se to například při sčítání větších čísel. Představme si, že máme dvě šestnáctibitová čísla, jedno v registrech BC, druhé v registrech DE, a chceme je sečíst a výsledek uložit do registrů BC. Takhle jednoduše to nejde, žádnou instrukci na to nemáme, takže to musíme udělat krok po kroku. Nejprve si sečteme čísla na nižších pozicích (C + E) a výsledek uložíme do C. Ovšem pokud součet těchto číslic bude větší než 255, tak musíme při sčítání vyšší pozice přičíst (přenesenou) jedničku! Což je bez problémů, protože, jak víme: ADD nastaví správně příznak CY, a ADC ho dokáže započítat. Součet tedy naprogramujeme třeba takto:

Naštěstí instrukce MOV nijak neovlivňuje příznaky, takže stav příznaku CY tak, jak ho nastaví instrukce ADD, se až do provedení instrukce ADC nezmění.

Funguje to? Ověříme v emulátoru! Sečteme si čísla 1000 a 2000 (03E8h a 07D0h), výsledek by měl být 3000 (0BB8h)… Všimněte si, že při součtu nižších řádů (E8h+D0h) je nastaven bit přenosu, protože výsledek je větší než FFh.
aci

Jako má ADD své ADI, tak má ADC své ACI. K reistru A přičte zadanou konstantu a hodnotu příznaku CY.

sub, sui

Instrukce SUB od hodnoty v registru A odečte hodnotu zadaného registru a výsledek uloží do A. SUI dělá totéž, ale s osmibitovou konstantou. Pokud je výsledek menší než 0, tak se pokračuje od FFh dolů (-1 = FFh, -2 = FEh, …) a je nastaven příznak CY, který má tentokrát význam „výpůjčky“ (borrow).

sbb, sbi

Totéž jako SUB, SUI, ale tentokrát od výsledku odečte 1, pokud je nastaven příznak CY.

cmp, cpi

Tyto instrukce porovnají obsah registru A s jiným registrem (CMP) nebo konstantou (CPI) a nastaví příznakové bity takto:

Podmíněné instrukce skoku se pak mohou podle těchto hodnot rozhodnout.

Zajímavost: Instrukce CMP a CPI vnitřně dělají totéž jako instrukce SUB, SUI, tedy odečtou od A hodnotu parametru, nastaví příznaky, ale výsledek neuloží do A, ale zahodí ho.

inr, dcr

Velmi častá operace je zvýšení hodnoty o 1 nebo naopak odečtení 1. Vyšší jazyky, které vyšly z jazyka C, na to mají i operátory „++“ a „–„. INR přičte k registru 1, DCR odečte 1. Instrukce ovlivní příznaky S, Z, AC a P, CY ponechá tak jak je (v tom se liší od ADI 1 / SUI 1)

inx, dcx

INR a DCR pracují s osmibitovým registrem, INX a DCX pracují s dvojicí registrů, jako by byl jeden šestnáctibitový. Parametrem může být B, D, H nebo SP.

dad

Sčítání v šestnácti bitech. K obsahu registrů HL přičte BC, DE, HL nebo SP.

daa

Tahle instrukce souvisí s čísly ve formátu BCD. Jen ji tu takhle zmíním, že existuje, a její popis si nechám na jindy, adekvátně jejímu významu…

A jak se tedy násobí a dělí? Dostaneme se k tomu, nebojte, ale teď si odskočíme. Jump!

                                                                                       Instrukce 8080 – skoky

Kdyby nebyly skoky, tak by program prostě jen jel, jel, jel… a na konci by jel zase od začátku. Něco jako flašinet.

Předpokládám, že znáte nějaký vyšší jazyk. Pravděpodobně ten jazyk obsahuje příkaz, kterému se vyhýbáte jako čert kříži, i když tam z nějakého důvodu je. Pokud jste mladší ročníky a začali jste s nějakým moderním jazykem, tak před vámi možná dokonce existenci toho příkazu úplně zatajili. Každopádně vám řekli, že to je zlo, nesystémovost, vede to ke špatným věcem a vůbec – pokaždé, když použijete GOTO, tak Bůh zabije koťátko.

Vítejte ve světě, kde je GOTO tím hlavním nástrojem.

Totiž, aby bylo jasno: V assembleru nejsou objekty, třídy, metody… Dokonce tam nejsou ani řídicí struktury. Není tam cyklus FOR, WHILE, není ani IF / ELSE. Ba co hůř – nejsou ani datové typy. Zapomeňte na řetězce, zapomeňte na datové struktury, jediné, co máte, je číslo. Zapomeňte na lokální proměnné. Nic z toho v assembleru nedostanete. Je to tvrdý svět – člověk proti křemíku. Nic vám neodpustí, nic za vás nedomyslí. Ale zase má jiné výhody: můžete program optimalizovat do nejmenších podrobností a detailů a za týden práce máte vymazlený program, co byste ve vyšším jazyce psali jedno odpoledne. Možná je rychlejší, možná je kratší, každopádně v něm můžou číhat velmi zákeřné chyby, které nemáte ve vyšším jazyce šanci udělat.

„Ale jak tedy udělám smyčku? Jak cyklus? Jak vnořím podmínky? Vždyť bez těchto základních konstrukcí nelze programovat!“ To si povíme za chvíli, teď si ukážeme, co máme k dispozici.

jmp

To je ono, to zlé GOTO. Tady se jmenuje JMP (jako že „jump“) a má jeden parametr. Tím je šestnáctibitové číslo – adresa, na kterou se skočí, tj. ze které bude procesor číst další instrukci. Vnitřně funguje tak, že to šestnáctibitové číslo, které je součástí instrukce, uloží do registru PC. Ten obsahuje (už jsme si to říkali) adresu, ze které se čte aktuální instrukce. Když tedy do PC uložíme číslo 0123h, bude se další instrukce číst z adresy 0123h.

Když takový program píšete, musíte znát adresu, kde bude ta cílová instrukce uložena. Naštěstí si to nemusíte počítat, to za vás dělá překladač. Vy jen překladači řeknete, kde bude ležet první instrukce (.org, vzpomínáte?), a zbytek adres si dopočítá za vás. Vy si můžete jednotlivé body pojmenovat symbolickými názvy a překladač je za vás správně vyhodnotí. Nějak takhle:

Což je samosebou zcela smyšlený příklad, ve skutečnosti by ho takhle nikdo nenapsal, ale je hezky vidět, jak instrukce JMP skáčou dopředu i dozadu. Zkuste si ho chvíli krokovat a uvidíte…

call, ret

Víte, nebyl jsem tak úplně upřímný. GOTO není jediné, co máte k dispozici. Ještě můžete použít GOSUB / RETURN. Pokud znáte BASIC, víte, co tyto instrukce dělají – volají podprogram. Ve vyšších jazycích je to něco jako procedura / funkce, ale opravdu jen velmi vzdáleně: nejsou žádné lokální proměnné, nejsou parametry, nejsou návratové hodnoty. Je tedy konvence, která říká, že podprogram, pokud něco vrací, tak by to měl vracet v registru A nebo HL, ale není to vůbec nezbytné – když na to přijde, tak váš podprogram může vrátit údaje v registru E, B a návdavkem ještě v příznaku CY.

Pokud v podprogramu změníte hodnotu registru, zůstane změněná i po návratu do hlavního programu. Musíte s tím počítat, a pokud si nechcete přepisovat hodnoty v registrech, tak si nezapomeňte na začátku podprogramu potřebné hodnoty uložit na zásobník (PUSH) a před návratem zase ze zásobníku vybrat (POP). Ale pozor! Vždycky musíte vybrat přesně tolik údajů, kolik jste jich uložili, protože jinak se stanou strašlivé věci. Jaké? Hned si ukážeme.

Jak taková instrukce CALL funguje? CALL má jeden parametr, kterým je šestnáctibitová adresa, jako u instrukce JMP. CALL nejprve vezme adresu následující instrukce (říká se jí „návratová adresa“), tu uloží na zásobník, a pak provede skok na zadanou adresu, stejně jako JMP. Instrukce RET vezme hodnotu ze zásobníku (měla by tam být ta návratová adresa, kterou tam uložila instrukce CALL) a skočí na ni. provádění programu tak pokračuje za tou instrukcí CALL, která volala podprogram.

Pokud si v podprogramu uložíte obsah registru (třeba HL pomocí PUSH H), bude na zásobníku HL a pod ním návratová adresa. Před návratem tedy musíte HL zase odebrat (nejčastěji pomocí POP něco), aby se RET vrátila tam, kam má. Pokud byste hodnotu neodebrali, RET by obsah zásobníku, tj. uloženou hodnotu registrů HL, považovala za návratovou adresu a skočila by tam. Naopak pokud byste si ze zásobníku vyzvedli víc údajů, než jste do něj vložili, byla by mezi nima i návratová adresa, takže RET by se vrátila úplně někam jinam.

Ano, OBČAS se takové triky dělají, ale upozorňuju dopředu: dělají je programátoři, kteří vědí co dělají a proč. Mají své místo ve chvíli, kdy hledáte, jak ušetřit nějaký ten bajt / nějaký ten takt procesoru, ale v naprosté většině případů je přebývající POP nebo PUSH chyba, která povede k pádu celého systému.

pchl

Prosím, nečíst P-Ch-L (podle vzoru Pche!), ale P-C-H-L. Když to přečtete správně, napoví vám, jak funguje. Do registru PC uloží obsah HL (PC=HL). Je to tedy něco jako JMP na adresu, uloženou v HL.

rst

RST je taková zkratka pro CALL na některé oblíbené adresy. Instrukcí RST je 8, číslovaných 0-7, a skáčou na adresu 8*N (kde N je to číslo). RST 0 je tedy totéž co CALL 0, RST 1 je CALL 8, RST 2 je CALL 16 (CALL 0010h) a tak dál… až RST 7 je totéž jako CALL 0038h. Oproti instrukci CALL, která zabírá 3 bajty (1 bajt instrukční kód 2 bajty adresa) má instrukce RST jen 1 bajt, navíc se provede rychleji než CALL. V mnoha systémech jsou proto na těchto adresách připravené často používané podprogramy. Namátkou ZX Spectrum používá RST 2 (v mnemonice procesoru Z80 označená jako RST 10h) pro vypsání znaku s ASCII kódem, který je v registru A, na výstup (obrazovku).

podmíněné skoky

Je hezké, že program skáče jako srnka, ale mnohem lepší a užitečnější by bylo, kdyby mohl nějak reagovat na to, co se počítá. K tomu slouží podmíněné instrukce Jcond, Ccond a Rcond. „Cond“ je označení podmínky, která se má testovat. Vždy se testuje hodnota některého příznaku S, Z, CY nebo P.

Podmínky mají i své mnemotechnické názvy: Carry, Not Carry, Zero, Not Zero, Minus, Plus, Parity Even, Parity Odd.

Podmíněné skoky, odvozené od JMP, jsou tedy JC, JNC, JZ, JNZ, JM, JP, JPE a JPO. Pracují tak, že otestují příslušný podmínkový bit. Pokud platí podmínka, provede se skok, pokud není splněna, pokračuje se dál. Například instrukce JZ 0123h zkontroluje nejprve, jestli je příznak Z=1. Pokud ano, skočí na adresu 0123h, pokud ne, pokračuje dál.

Ano, takhle nějak funguje IF cond THEN GOTO x. „Pokud je splněno, skoč tam a tam.“ V praxi budete chtít často zapsat něco jako „Pokud je výsledek 0, udělej ještě to a to…“ (tedy chování obdobné známé konstrukci IF) V assembleru to vyřešíte tak, že zapíšete „Pokud výsledek není 0, tak přeskoč až za blok příkazů“.

Takto tedy funguje konstrukce IF – THEN a IF – THEN – ELSE.

Podobně jako jsou podmíněné instrukce skoku JMP, tak můžeme vytvořit podmíněné skoky do podprogramu (Ccond – CZ, CNZ, CC, CNC, CM, CP, CPE, CPO) a podmíněné návraty (RZ, RNZ, RC, RNC, RM, RP, RPE, RPO). Fungují stejně jako CALL a RET, ale provedou se pouze pokud je splněná podmínka.

while!

Dobře, ukážeme si jednu konstrukci z vyššího jazyka, přepsanou do assembleru. Představte si takový počítaný cyklus WHILE:

Tedy dokud je hodnota B vyšší než 0, tak od něj odečti 1, zavolej funkci ctiKlav, výsledek ulož do A, a zavolej funkci pisObr s parametrem v A.

Řekněme si na rovinu – nic takového jako „výsledek ulož do registru A“ nemáme. Je na autorovi podprogramu ctiKlav, aby vrátil požadované v registru A. Stejně tak nemůžeme podprogramu pisObr předávat nějaké parametry – pokud podprogram očekává nějakou hodnotu v registru A, je na nás, abychom ji do toho registru připravili. Nemluvě o tom, že budeme používat registr B jako počítadlo průchodů, takže pokud nám ho některý z podprogramů přepíše, tak algoritmus nebude fungovat.

Proto je, a to vám kladu na srdce, dobrým zvykem u každého podprogramu napsat do dokumentace, ve kterém registru očekává parametr, ve kterém vrací hodnotu, a zmínit, pokud nějaký registr přepíše, ať s tím může ten, kdo ten podprogram použije, správně naložit. (Kdysi jsem četl historku o tom, jak se kdosi v 80. letech bál použít podprogramy monitoru, protože v dokumentaci u nich psali poznámky jako: Ničí registry D, E. Čímž autor samosebou myslel, že přepíše hodnoty v nich uložené, ovšem nebohý juniorní programátor se bál toho výrazu ničí – počítač je tak drahý stroj, tak si přeci nevezme na svědomí, aby se vevnitř něco zničilo.)

Tak jak tedy to výše zmíněné přepsat do assembleru? Řešení:

Budete používat nejrůznější varianty této konstrukce – s podmínkou na konci (do {…} while()) nebo s podmínkou uprostřed, ale vždy to bude plus mínus něco podobného.

Ony totiž všechny ty konstrukce, které znáte a máte rádi (for, while apod.), jsou nakonec často přeloženy do strojového jazyka, a to nějakým způsobem, který je velmi podobný tomuto. Tedy samé IF…THEN GOTO a GOTO.

GOTO!

Instrukce 8080 – rotace

autor: MARTIN MALY publikováno 23. 12, 2013

„Cože? Rotace? Proč ne něco Opravdu Důležitého?“ – ale ony jsou docela důležité, věřte mi, a když je správně použijete, tak ušetří spoustu času.

Procesor 8080 oplývá sadou instrukcí, která dokáže provádět takzvané bitové rotace registru A. Co to znamená?

Představme si registr A jako osm bitů, očíslovaných (od nejnižšího) 0-7. Představme si je napsané vedle sebe.

To je on. S ním budeme teď pracovat a jako první si ukážeme operaci „rotace vlevo“:

rlc

Instrukce RLC posune bity o 1 doleva. To znamená, že bit 0 se přesune na pozici 1, bit 1 na pozici 2, bit 2 na pozici 3 a tak dál, a bit 7, který nám vypadne zleva ven, se zase vrátí zprava na pozici 0. (A právě proto, že takhle „krouží“, se té operaci říká „rotace“. Kdyby vypadl a byl zahozen, byl by to „posuv“ – ale takové instrukce 8080 nemá). Bit 7 je zároveň zkopírován do příznaku CY.

rrc

Instrukce RRC posune bity o 1 doprava. To znamená, že bit 7 se přesune na pozici 6, bit 6 na pozici 5, bit 5 na pozici 4 a tak dál, a bit 0, který tentokrát vypadne vpravo, se vrátí zleva na pozici 7, a návdavkem je zkopírován do příznaku CY.

ral

Další dvě instrukce berou v úvahu i obsah příznaku CY. RAL funguje stejně jako RLC, ale s jedním rozdílem – bit 7, který zleva vypadne, je zapsán do příznaku CY, a hodnota z CY je přesunuta do pozice 0 v registru A. Graficky to vypadá nějak takto:

rar

RAR je obdoba předchozí funkce RAL, jen směr je opačný – bity se posouvají doprava, bit 0 jde do CY a „staré CY“ jde na pozici 7.

Víc rotací procesor 8080 nemá.

Jaké mají tyto operace smysl? Když se nad tím zamyslíte, je to analogické jako u desítkové soustavy: když máte číslo (123) a posunete ho o jednu pozici doleva (a zprava doplníte nulou), dostanete jeho desetinásobek (1230). Když ho posunete doprava, dostanete celočíselný výsledek dělení deseti. U dvojkové soustavy platí totéž – posun doleva je totéž jako vynásobit dvěma, posun doprava je dělení dvěma.

Trochu tam hapruje to rotování kolem dokola, ale to lze obejít pomocí vhodného domaskování nebo tím, že si předem nastavíte příznak CY na požadovanou hodnotu.

Dají se použít ještě na spoustě dalších míst – ale to si ještě ukážeme.

stc, cmc a jak nastavit příznak cy?

Přiznám se, že jsem váhal, kam zařadit instrukce STC a CMC, a nakonec je zařadím sem. Instrukce STC nastaví CY na 1, instrukce CMC neguje jeho hodnotu. Pokud chcete CY nastavit na nulu, musíte buď udělat STC a CMC, nebo (pokud vám nevadí, že přijdete o hodnotu v příznacích S, Z, P) zkusit třeba CMP A – tato instrukce porovná registr A se sebou samotným. Výsledek je, nepřekvapivě, „hodnota se sobě rovná“, takže instrukce nastaví Z na 1 a S a CY nuluje.

rotace 8080 – souhrn

No related posts.

8080 – násobení

Když se sejdou tři sobi, tak se radost násobí…

Už jsme si řekli, že násobení nepatří mezi základní operace, kterými procesor 8080 oplývá. A rovnou můžu prozradit, že to ani u Z80, ani u 6502 není v tomto směru o moc lepší. Po pravdě si nevzpomínám na žádný osmibitový procesor, který by měl instrukci pro násobení. Neříkám že neexistoval, jen si na něj nevzpomínám. (Paměť mi osvěžil až Roman Bórik: osmibitové jednočipy – mikrokontroléry řady 8051/8052 mají instrukce násobení i dělení.)

Pokud chceme násobit, a taková potřeba na každého někdy přijde, musíme si vystačit s tím co máme a známe. A taky trošku zavzpomínat na základní školu.

Víme, že 3 krát 5 je vlastně 5 + 5 + 5. Třikrát se sečte pětka. Mohlo by to vypadat nějak takhle – násobíme obsah registru B obsahem registru C a výsledek ukládáme v A:

Rovnou upozorňuju, že to je jeden z nejzoufalejších kódů, co tu budou zveřejněné. Je špatný z mnoha důvodů. Zaprvé – když násobím dvě osmibitová čísla, může být výsledek až šestnáctibitový (prostý test: 255 * 255 = 65025 (FE01h)). Já tu sčítám hodnoty v registru A, který je osmibitový a přeteče už u čísla 255. Což, to by se dalo napravit snadno – místo sčítání v registru A můžu použít registry HL, přičítat k nim číslo z registrů DE a bude to… Nějak takto (opět násobíme B * C, výsledek jde do HL):

Teď už můžeme násobit v plném rozsahu, tenhle problém jsme vyřešili, ale je tu jiný problém. Totiž ten, že násobení trvá dlouho. Představte si, že B bude třeba 250 a C dvě. Budeme 250krát přičítat dvojku, stále dokola – ostatně zkuste si to v emulátoru nasimulovat, uvidíte sami. Co s tím?

Můžeme čísla na začátku prohodit (místo „250x přičti dvojku“ udělat „2x přičti 250“), ale to je řešení na půli cesty. Vlastně ne na půli cesty, ve skutečnosti na pytel! Správný postup je zahodit tenhle algoritmus a jít na to jinak.

násobení podruhé – rafinované

Spousta lidí tváří v tvář dvojkové soustavě strne a očekává, že přestanou fungovat postupy, které znají ze soustavy desítkové. Ale ony fungují docela dobře. Třeba to násobení se dá obstojně zařídit stejně, jako jsme se to učili ve třetí třídě ZŠ, když jsme násobili na papíře dvojciferná čísla pod sebou. Pamatujete?
 

Postup popíšu slovy. Začneme od nejnižšího řádu druhého činitele (4). Tím vynásobíme prvního činitele (4*26) a dostaneme první mezivýsledek (104). Ten platí pro nejnižší řád (je zapsaný úplně vpravo, zarovnaný s tím řádem, který právě zpracovávám). Pokračuju k vyššímu řádu druhého činitele. Vida, je to 3. Postup opakuju: vynásobím tím číslem první činitel (3*26) a druhý mezivýsledek (78) si zapíšu na pozici desítek, tedy o řád výš než předchozí. A takhle budu pokračovat, dokud nepronásobím všechny řády druhého činitele. Nakonec mezivýsledky sečtu.

Tak. A jde to tak i ve dvojkové soustavě? Zkusíme to. Kolik je dvojkově 13 * 9?

Postup je naprosto stejný – taky násobíme a posouváme o řád, ovšem situaci máme o mnoho jednodušší: Protože pracujeme ve dvojkové soustavě, tak násobíme vždy jen buď jedničkou (tedy mezisoučet je roven prvnímu činiteli), nebo nulou (a mezisoučet je 0). Mezisoučty postupně posouváme doleva a přičítáme.

Tak, s touhle vědomostí by určitě šlo napsat násobící algoritmus, který nemá tu nectnost, že by závisel na hodnotě činitele. Jeho hlavní smyčka proběhne tolikrát, kolik má druhý činitel bitů. Ale předtím, než se do něj pustíme, si řekneme ještě pár tipů.

K posunu registru o jeden bit doleva můžeme samozřejmě použít instrukci rotace. Ovšem tady budeme rotovat rovnou dva registry najednou. Nejjednodušší způsob bude použít instrukci DAD H. Ta, jestli si vzpomínáte, přičte k registrovému páru HL hodnotu svého parametru – tedy HL. Sečíst HL a HL znamená vlastně udělat 2*HL, a z hlediska bitového je to totéž jako posunout obsah registru doleva o 1 bit a zprava doplnit nulou. Tedy přesně to, co se děje v tom algoritmu výše.

Troufnete si napsat algoritmus, který vynásobí obsah registrů D a E a výsledek uloží do HL? Zkuste to…

Řešení je následující:

Může vám připadat trošku zmatené, ale nebojte, hned si to projdeme.

Na začátku nastavím zásobník na rozumnou pozici. Připravím si do registrů D a E hodnoty, které budeme násobit (13 a 9). Samosebou bych mohl použít LXI D, 0x0D09, ale pro názornost je to takhle rozepsané. Pak volám podprogram Mul8 – jako že „Multiplication, 8 bits“.

V podprogramu si nejdřív vynuluju registry HL. Tam se budou průběžně sčítat mezivýsledky. Do B si připravím hodnotu 8 – to je počítadlo, kolikrát provedu hlavní smyčku. Budu ji provádět osmkrát, pro každý řád jednou, tak proto ta osmička. Teď bych potřeboval, aby v DE byl jen druhý činitel (tedy v D 0 a v E to, co tam je). Přesunu si tedy obsah D do registru C (mám teď činitele v registrech C a E) a registr D si vynuluju. A teď může začít vlastní kouzlo…

Podívám se, jakou hodnotu má nejnižší bit registru C, a posunu si ho o jednu pozici doprava  (v příštím průchodu tak budu kontrolovat pozici 1, pak pozici 2 atd.) To ale nemůžu udělat přímo, takže si jej musím nejprve přesunout do registru A, tam provést RRC a pak uložit zpátky do C. Instrukce RRC dělá obě věci, co potřebuju, najednou – uloží nejnižší bit (do příznaku CY) a rotuje o jednu pozici doprava.

Podle hodnoty nejnižšího bitu (mám ho teď v CY) se rozhodnu, jestli mezisoučet (DE) přičtu k celkovému výsledku (pokud je 1), nebo nepřičtu (CY=0). Použiju podmíněný skok: Pokud není CY (JNC), tak skoč dál. Pokud je CY, pokračuj a přičti DE k HL (HL=HL*DE)

Tím mám jeden krok skoro za sebou. Teď už jen musím posunout mezisoučet v DE o jednu pozici doleva. Vyřeším to tak, že ho přičtu k sobě samotnému (tedy DE = DE + DE). A protože na to instrukci nemáme, tak si pomocí XCHG na chvíli prohodíme DE a HL a provedeme HL = HL + HL.

Pak už jen snížím počet průchodů smyčkou (DCR B), a pokud ještě nejsme na nule, tak to celé provedeme znovu.

A věřte nebo ne, na tomhle principu je založena naprostá většina softwarových násobiček.

násobení dvaapůlté – optimalizované

Můžeme u předchozího algoritmu ušetřit pár bajtů, dva registry a nějaký ten čas, a to tím, že druhý činitel umístím do registru H, zatímco mezisoučet bude neustále v HL. Zní to divně? Divné to teprve začne být!

Ve skutečnosti při tomto postupu nepůjdeme od nejmenšího bitu, ale od nejvyššího. Náš postup nebude ten, že při každém průchodu přičteme první činitel, patřičně posunutý doleva (*2), ale při každém průchodu naopak vynásobíme mezisoučet dvěmi a případně přičteme první činitel. Matematicky místo (A * 2⁰ * b0) + (A * 2¹ * b1) + (A* 2² *b2) + … (A je první činitel, b0-b7 bity druhého činitele) budeme provádět (((A*b7)*2+(A*b6))*2+(A*b5))*2… Pro zájemce: Hornerovo schéma. (Náš učitel programování tomu říkal tvrdošíjně „Hornerovo šéma“ – ale on říkal taky místo while cosi, co znělo jako [hwajl]…)

Využijeme toho, jak se chová instrukce DAD H. Už jsme si řekli, že udělá HL = HL + HL, tedy HL * 2. Tedy vlastně posune obsah HL o jednu pozici doleva. Zároveň nastaví příznak CY, pokud hodnota přeteče – v tomto případě přeteče, pokud je nejvyšší bit registru H = 1… takže jako by zkopíroval ten nejvyšší bit do příznaku CY.

Takže jednou instrukcí tu máme:

§  posun hodnoty v registru H o jeden bit doleva (tedy můžeme jít bit po bitu od b7 po b0)

§  při každém posunu udělá vlastně jeden bit prostoru pro mezisoučet v HL (to, že H v průběhu výpočtu ve vyšších bitech obsahuje nějaký zmatek, to nevadí, protože „zmatek“ se postupem času odsune pryč)

§  vynásobí mezisoučet dvěma.

Tolik dobra za jednu cenu, že?
Vyšší dívčí? Nebojte se, vpravíte se do toho. V očích vám teď vidím otázku: Zešílels? Tohle přeci není normální!

Takže: Ano, zešílel, ale to s tím nijak nesouvisí, a ne, v assembleru je tohle naprosto normální. Když chcete, hrajete o každý bit v registru, takt procesoru, bajt v paměti… A někdy ani nechcete, ale musíte!

násobení potřetí

V assembleru má optimalizace vždycky dvě fáze. V té první vyhazujete instrukce, které jste napsali zbytečně – program bude kratší i rychlejší. V té druhé si musíte vybrat: Chcete kratší kód? Musíte dělat triky, co vás budou stát nějaký ten čas. Chcete kód rychlý? Musíte obětovat prostor. I u algoritmu násobení stojíte před stejným rozhodováním: rychleji? Bude to něco stát…

Úplně nejrychlejší algoritmus by byl takový, který by měl v paměti výsledky všech možných kombinací pro násobení (v případě osmibitových činitelů by jich bylo 65536) a prostě by si jen sáhnul tam, kam potřebuje. Taková tabulka by ale zabrala spoustu paměti a pro vlastní program by v adresním prostoru běžného osmibitového procesoru zůstalo… ehm… přesně 0 bajtů. Naštěstí existují kompromisní řešení, kdy si do tabulky uložíme jen pár konstant (třeba 1024) a zbytek dopočítáme. Je to opět kompromis mezi rychlostí a velikostí. A jak tedy bude násobení vzor 3 vypadat? To si nechme na jindy…

Instrukce 8080 – logické operace

 „Milý autore, tvůj seriál je zmatený a nemá žádnou logiku! Logika v něm chybí! Váš čtenář.“ – „Milý čtenáři, logika tu nechybí. Logika je tu právě teď!“

Protože předpokládám, že všichni, co to čtete, jste už nějaký programovací jazyk zvládli, tak si nemusíme, doufám, vysvětlovat, co je to AND, OR a XOR. Některým tužším borcům naznačím: &, | a ^. Už jo, už to berou, tak pojďme na to.

ana, ani

Provede operaci AND mezi registry A a vybraným registrem (ANA), nebo mezi registrem A a zadanou osmibitovou konstantou (ANI). Hezky bit po bitu, a výsledek jde zpátky do A. Pokud se na parametr budeme dívat jako na masku, kterou je třeba aplikovat na registr A, tak vězte, že kde má maska 1, tam zůstane A nedotčeno, kde má 0, tam bude vynulováno. Instrukce ovlivňují všechny příznaky.

ora, ori

Provede operaci OR mezi registry A a vybraným registrem (ORA), nebo mezi registrem A a zadanou osmibitovou konstantou (ORI). Hezky bit po bitu, a výsledek jde zpátky do A. Pokud se na parametr budeme dívat jako na masku, kterou je třeba aplikovat na registr A, tak vězte, že kde má maska 0, tam zůstane A nedotčeno, kde má 1, tam bude nastaveno na 1. Instrukce ovlivňují všechny příznaky.

xra, xri

Provede operaci XOR mezi registry A a vybraným registrem (XRA), nebo mezi registrem A a zadanou osmibitovou konstantou (XRI). Hezky bit po bitu, a výsledek jde zpátky do A. Pokud se na parametr budeme dívat jako na masku, která se bude aplikovat na registr A, tak vězte, že kde má maska 0, tam zůstane A nedotčeno, kde má 1, tam bude změněna hodnota příslušného bitu v A. Instrukce ovlivňují všechny příznaky.

cma

Vezme obsah registru A a zneguje ho, tj. všechny 1 prohodí za 0 (a obráceně). Instrukce nijak neovlivní příznaky.

praktické použití

Takhle odsud to možná vypadá jako nějaká zajímavost pro nerdy, ale věřte, že v assembleru budete tyhle instrukce používat často. Například pro nastavení konkrétního bitu použijete ORI 01h (02h, 04h, 08h, 10h, 20h, 40h, 80h). Pro vynulování bitu použijete AND, ale v negované podobě – tam, kde chcete bit nastavit na 0, nechte 0, všude jinde 1. Chcete-li vynulovat bit 3 (To je on: „….3…“), použijete konstantu, která má všude 1, s výjimkou pozice 3: „11110111“. Tedy F7h.

Operace XOR slouží krom změny hodnot bitů i k jednomu hezkému fíglu: pokud potřebujete vynulovat registr A a nezáleží vám na tom, že se změní hodnota příznaků, použijte XRA A. Taková instrukce zabere jen jeden bajt a je i proti MVI A,0 rychlejší.

Instrukce CMA má efekt stejný jako XRI FFh – ale nemění příznaky a zabere jen jeden bajt.

Teď jsme se dostali do bodu, kdy zbývá probrat už jen šest instrukcí procesoru 8080, takže je opět vhodná chvíle na drobné odbočení, ať to máme pestřejší…

No related post

Instrukce a operační kód

… a když na vás o půlnoci zakřičím: „C3h!“, tak vy vyskočíte!

Jistě jste se v předchozích kapitolách dívali na to, jaké kódy patří k jakým instrukcím a zaujalo vás, že „MVI A, něco“ má vždycky první bajt 3Eh. (Cože? Nevšimli? Nezaujalo? A zvážili jste, že byste se místo assembleru učili třeba Javu?)

Nebo taková instrukce MOV – ať už je jakákoli, je její kód vždycky mezi 40h a 7Fh. Má to svoji logiku. Schválně, podívejte se sami (ten program je naprosto nesmyslný, proto se nedívejte, co dělá, ale jak je přeložený!)

Dá se v tom vypozorovat určitá pravidelnost, že? Instrukce MOV obecně vypadá totiž po jednotlivých bitech takto:

Trojice bitů D a S kódují jednotlivé registry (D = cílový, S = zdrojový). Registry jsou kódované následujícím způsobem:

Dva nejvyšší bity jsou 0 a 1. Pokud má instrukce nejvyšší dva bity takto nastavené, ví dekodér instrukcí, že jde o MOV, že se bude přesouvat z registru do registru, a informaci o tom, ze kterého do kterého najde v bitech 5-3, resp. 2-0. (Ano, je tu výjimka – přesun z registru M do registru M není možný a operační kód, který by taková instrukce měla (76h) je vyhražen pro jinou instrukci.)

Co třeba instrukce s takovýmhle bitovým obrazem?

Možné kódy jsou 06h, 0Eh, 16h, …, 3Eh. Tato bitová kombinace říká dekodéru, že se jedná o instrukci MVI, tedy přesun následujícího bajtu do některého z registrů. Který registr to bude, to je opět zakódované v operačním kódu – jsou to ty tři bity „d“.

A co takováhle instrukce?

Možné kódy jsou 04h, 0Ch, 14h, …, 3Ch. Tentokrát se jedná o instrukci INR a v operačním kódu je opět určeno, o jaký registr půjde.

Když se podíváte do tabulky instrukcí, zjistíte, že instrukce nejsou rozmístěny nahodile. V první čtvrtině (00-3Fh) jsou nejrůznější přesuny, rotace, inkrementace a dekrementace. Druhá čtvrtina (40h-7Fh) patří přesunům (MOV), třetí třetina (80h-BFh) obsahuje aritmetické instrukce, které pracují s registry (ADD, ADC, …) a poslední čtvrtina (C0h-FFh) obsahuje převážně skoky, operace s přímým operandem a operace se zásobníkem.

Takováto výstavba instrukcí je dána potřebou mít co nejjednodušší dekodér. Později, až se podíváme na operační kódy procesorů 6502 nebo 680x, zjistíme, že jsou v dodržování tohoto principu mnohem důslednější a že i přes své zdánlivé limity nabízejí programátorovi mnohem větší svobodu.

s.

8080 – Ahoj světe!

Konečně! Konečně jsme se dostali do bodu, kdy si vypíšeme ono známé a populární AHOJ SVĚTE, a pak už nás nic nezastaví!

Samozřejmě, s čistým assemblerem toho moc nedokážeme. Potřebujeme taky stroj, který náš program vykoná. Teď nastala ta chvíle, kdy si můžete vytáhnout své pečlivě schraňované PMI-80 a… Cože, vy nemáte PMI-80? No dobrá tedy. Použijeme PMD-85. Ten snad všichni máte. Támhle vzadu někdo přikyvuje… jo aha, to je RM-Team, to je výjimka, vy ostatní, hm… nemáte… To nevadí. Půjčte si alespoň emulátor PMD-85.

Tak. Náš první opravdový program vypíše na obrazovku „AHOJ SVETE“ a skončí. Jak to udělá?

No, zaprvé bude potřeba někde v paměti mít uložená písmenka A, H, O, J… atd. jak se mají vypsat. Jedno po druhém budeme brát a zobrazovat je na displeji. Bude tedy rozumné, když si adresu toho řetězce uložíme do nějakých registrů. Z toho, co jsme si řekli, víme, že pro podobné účely je nejvhodnější dvojice registrů HL. Znak načteme do registru A pomocí MOV A,M, na další pozici se přesuneme pomocí INX H… Základní kostra tedy bude vypadat nějak takhle:

Zbývá vyřešit pár detailů. Třeba: Jak vypíšeme ten znak? Tady nám pomůže monitor PMD-85. Monitor není, prosím pěkně, ta bedna, na kterou civíte – ve světě osmibitových počítačů se „monitor“ říkalo základnímu obslužnému programu, který umožňoval nějaké elementární operace se systémem – prohlédnout si paměť, změnit její obsah, spustit program, uložit ho na záznamové zařízení atd. Něco jako pozdější „operační systém“. Takový monitor býval uložený v pamětech typu ROM (spíš EPROM, ale to je nepodstatný detail) a krom toho, že komunikoval s obsluhou, tak většinou nabízel i nějaké podprogramy, které může využít programátor ke své práci.

Když se podíváme do výpisu monitoru PMD-85 (k dispozici je třeba na stránkách RM-teamu), co nám nabízí, najdeme následující kousek:

To je asi to, co hledáme. Podprogram vypíše znak z registru A na obrazovku. Pokud to je 1Ch, tak smaže obrazovku, 0Dh odřádkuje, 0Ah ignoruje, zbytek vypíše. Vstup očekává v registru A. Ty tři řádky pod tím – (C03EH) – kurzor – adresa ve V-RAM – teď budeme ignorovat, budeme doufat, že je to všechno nastavené, jak má být. (Pro zvídavé – C03EH v závorkách naznačuje, že se jedná o obsah paměti na adrese C03Eh… Tady půjde pravděpodobně o dva bajty na adresách C03Eh a C03Fh – ale to bych sem teď opravdu netahal.)

V popise je dále napsáno, že výstupem je obrazovka – jo, to tak nějak čekáme, a že program používá PSW. Vzpomeňte si, jak jsme si říkali, že je dobré do dokumentace napsat, které registry náš podprogram přepíše. Tento podprogram je slušný, změní jen A a F (neboli PSW), zbytek zůstane zachovaný, tudíž nemusíme hodnotu registrů HL (kde máme adresu toho řetězce) uschovávat.

Takže je jasno: Výpis si vyřídíme pomocí CALL 8500h, neboli CALL PRTOUT.

PRTOUT je symbolické jméno, abychom si nemuseli pamatovat adresu 8500h – napovídá, že půjde o nějaký výpis (PRINT OUT). Podobných programů je v monitoru velké množství – třeba KEYBD, jak už název napovídá, bude mít něco společného s klávesnicí (KEYBoarD), pravděpodobně čtení znaku z klávesnice. Každopádně se KEYBD pamatuje snáze než 84A1h, navíc když uděláte překlep a napíšete KEYDB, překladač vás upozorní, že takovou adresu nezná, zato když se uklepnete na 841Ah, nikdo vás neupozorní a program nebude fungovat. Jak používat tyto symbolické názvy se dozvíte v další lekci.

Další problém, který je třeba vyřešit: Program musí nějak poznat, že už vypsal všechny znaky a že má přestat. Kdyby to nepoznal, tak vypíše všechno až doalelujá a nikdy neskončí. Můžeme si zase zvolit nějaký registr jako počítadlo znaků, dát do něj předem délku, při každém průchodu zmenšit o 1, a když dojdeme k nule, tak skončit. To je řešení logické, ale má svoje nevýhody: Zaprvé, musíme znát délku řetězce. To by za nás dokázal pohlídat překladač. Zadruhé: nejdelší řetězec bude mít 256 znaků. I to by se dalo vyřešit, kdybychom pro počítadlo vyhradili dvojici registrů. Jenže takové řešení je delší než to, které nakonec použijeme my.

My totiž uložíme do paměti řetězec znaků AHOJ SVETE, a hned za něj uložíme nulu. Ti z vás, kteří znají céčko, teď pravděpodobně pokyvují hlavou, že jim je tohle řešení povědomé. Ano, je to přesně to. Ve smyčce pak čteme jednotlivé znaky a kontrolujeme, jestli to není náhodou 0. Pokud to je 0, tak jsme skončili.

Jak zkontrolovat, jestli je bajt 0? MOV A,M nijak nepomůže, tato instrukce neovlivňuje příznaky. Můžeme použít CPI 0, tedy instrukci pro porovnání. Nebo můžeme opět použít jednoduchý trik: Použijeme instrukci, která nezmění hodnotu, ale nastaví příznaky… Nabízí se operace OR nebo AND, tedy instrukce ORA A nebo ANA A. OR hodnoty s ní samotnou je stále ta hodnota – ale nastaví příznaky S, Z, AC, P a CY. Nás bude zajímat příznak Z, který bude 1, je-li hodnota nulová.

Nová verze vypadá tedy takto:

Krok po kroku: Připravíme si adresu textu do registrů HL (LXI H, text). Smyčka začíná tím, že přečteme znak z adresy HL do registru A (MOV A,M), porovnáme hodnotu samu se sebou (ORA A) a pokud je to nula, skáčeme na adresu STOP (JZ stop). Pokud ne, tak voláme PRTOUT, zvýšíme adresu v HL o 1 a pokračujeme v provádění smyčky.

Stop se v našem programu implementuje jako RET – tedy návrat zpátky do toho místa, odkud byl program spuštěn. V našem případě tedy zpátky do monitoru PMD-85. Je vyřešen trochu nešikovně – podívejte se sami: JZ na adresu STOP, a na té adrese je jen RET. Pokud bychom po vypsání chtěli dělat ještě něco, můžeme to napsat od návěští STOP dál. Ale jestliže nic dělat nechceme, můžeme se přímo ze smyčky vrátit – místo instrukce JZ na adresu, kde je instrukce RET, můžeme přímo použít podmíněnou instrukci RZ.

Zbývá vyřešit poslední problém, totiž jak napsat to „AHOJ SVETE“ do paměti od adresy TEXT.

K tomu slouží pseudoinstrukce DB. Podobně jako ORG říká překladači „program bude uložen od této adresy“, tak DB říká: „To, co je parametrem téhle pseudoinstrukce ulož do kódu jako jeden bajt.“ Takže kdekoli se ve zdrojovém kódu objeví třeba DB 41h, tam překladač vloží bajt 41h. Což je zároveň ASCII kód znaku A. Pokud chceme vložit ASCII kód znaku A, nemusíme hledat v tabulkách, že to je 41h – stačí zapsat DB „A“ a překladač to vyřeší za nás.

Takže můžeme napsat DB „A“, „H“, „O“, „J“ … anebo jednodušeji: DB „AHOJ SVETE“ Když překladač za DB narazí na řetězec, uloží kódy jednotlivých znaků do paměti po sobě tak jak jdou v řetězci.

Samozřejmě je dobré dát si pozor na to, aby se program nikdy na tuhle adresu nedostal, protože kdyby začal provádět „instrukce“ (ve skutečnosti nějaká data), tak by se mohlo stát cokoli.

Náš program tedy vypadá nakonec takto:

Tentokrát nám krokování v debuggeru nepomůže – u instrukce CALL 8500h debugger vykolejí, protože na takové adrese nic nemá. Musíme náš program přenést do počítače. Přeložte si ho a soustřeďte se na listing:

Na adresu 0000 je třeba zapsat hodnotu 21 (vše hexadecimálně), na 0001 hodnotu 0D, na 0002 hodnotu 00, na 0003 hodnotu 7E… na další adresy pak hodnoty B7, C8, CD, 00, 85, 23, … a konečně na adresu 0018 zapíšeme nulu.

Zapněte si svá Péemdéčka (nebo si spusťte v druhém okně emulátor PMD-85) a napište: SUB 000021 (a klávesu EOL / ENTER). Tím se do paměti na adresu 0000 uloží hodnota 21. V příkazovém řádku se teď objevilo SUB 0001 – stačí tedy dopsat 0D a EOL (ENTER)… Nebo můžete využít toho, že příkaz SUB dokáže uložit víc hodnot najednou, a napsat po sobě toto:

Monitor vám po odeslání každého řádku připraví nový příkaz SUB… Když odešlete poslední řádek, stiskněte EOL (na PC emulátoru ENTER) bez zadání dat. PMD vypíše chybu a očekává nový příkaz. Ke spuštění programu slouží v monitoru PMD-85 instrukce JUMP xxxx, kde xxxx je hexadecimálně zadaná adresa. Zkuste to:

(a EOL / Enter)

Pokud jste neudělali chybu, objeví se to, co jsme chtěli:

Zvládli jsme to! Pokořili jsme kus křemíku a donutili ho udělat to, co jsme chtěli. Malý krok pro člověka… atakdál!

Tip: Můžete si ten program vyzkoušet samozřejmě i v online vývojovém prostředí ASM80. Uložte si tento soubor pod nějakým názvem s příponou .a80. Do kódu napište na prázdný řádek, třeba na samotný začátek, pseudoinstrukci „.ENGINE pmd“ (bez uvozovek, samosebou). Když pak kliknete na EMULATE, program se přeloží, spustí se emulátor PMD-85 a v něm už bude váš program nahraný od té adresy, kterou jste zadali v ORG. Ušetří vám to práci s přepisováním všech těch kódů. A od toho přeci počítače máme – aby nám ušetřili práci. Ne?

Pseudoinstrukce

A jestli vám vadí to „pseudo-„, nemáte rádi věci, co jsou jen „jako“ a raději chcete mít vše jasně nařízené, tak to nazývejte třeba „direktivy“.

Překladač (správně nazývaný assembler, ale už jsme si vysvětlili, že tohle slovo se taknějak přemigrovalo i na Jazyk Symbolických Adres, a já tentokrát potřebuju zdůraznit, že mám na mysli ne ten jazyk, ale opravdu překladač, přičemž jaksi mimochodem píšu asi nejdelší vsuvku na celém tomhle webu a doufám, že si vzpomenu, jak jsem chtěl tu větu dokončit…) plní hlavně dva úkoly:

1.     Překládá instrukce, zapsané v mnemotechnickém tvaru, tj. v podobě nějakých snadno zapamatovatelných názvů, na jejich instrukční kódy (MOV B, C => 41h).

2.     Počítá pozici v paměti a dovoluje je nazvat nějakým lidským jménem, abychom mohli napsat „CALL podprogram“ a nemuseli přemýšlet, na jaké že adrese ten podprogram je.

Kromě těchto instrukcí („pravých“ instrukcí) pracuje překladač ještě s takzvanými pseudoinstrukcemi. „Pseudo-“ proto, že se zapisují jako instrukce, ale ve skutečnosti je procesor nezná. Zná je překladač a nějak se podle nich zachová. Některé už jsme si ukázali.

org adresa

Oznámí prohlížeči, že toto místo programu bude na dané adrese a další instrukce se uloží za něj. Díky tomu si překladač správně spočítá adresy.

db číslo [,číslo, …]

Uloží do výsledného kódu bajt (nebo bajty). Místo čísla můžeme zapsat i řetězec do uvozovek – překladač s ním naloží jako se seznamem ASCII kódů.

dw číslo [,číslo, …]

Uloží do výsledného kódu šestnáctibitové číslo jako dva bajty. Pokud je víc parametrů, uloží víc dvojbajtových hodnot.

ds počet

Řekne překladači, že má vynechat určitý počet bajtů. Používá se v případech, že chceme nechat nějaký prostor volný (např. pro buffer) a je nám jedno, jaký bude jeho obsah na začátku, stačí, když bude N bajtů dlouhý.

návěští equ hodnota

Přiřadí jménu návěští nějakou hodnotu. Třeba z minulé lekce:

Od této chvíle už nemusíme řešit, jestli jsme nespletli adresu – prostě napíšeme CALL PRTOUT a překladač zjistí, že jsme PRTOUT nadefinovali takovouhle hodnotu, tak ji použije.

poznámka k návěštím

Každé jméno návěští je unikátní. To znamená, že pokud použijete stejné jméno znovu k označení nějaké pozice v paměti, nebo pokud už nadefinovanému jménu budete přiřazovat hodnotu pomocí EQU, překladač vám vyhodí chybové hlášení. Je to logické – kdybyste si definovali dvakrát stejný název, překladač by nevěděl, jaká adresa platí…

Následující pseudoinstrukce jsou popsané tak, jak je implementuje překladač ASM80. V jiných překladačích se jejich syntax může lišit.

.include jméno-souboru

Na místo této instrukce vloží obsah zadaného souboru, jako byste ho tam vložili pomocí copy-paste. Ale asi není potřeba vysvětlovat víc. Všimněte si tečky na začátku pseudoinstrukce… Správně by se měla psát u všech pseudoinstrukcí (je to taková docela užitečná konvence), ale z historických důvodů se u těch výše zmíněných nepoužívá.

.if výraz – .endif

Překladač vyhodnotí výraz, a pokud je nenulový, pokračuje v překladu. Pokud je nula, vynechá všechny řádky až do nejbližšího .ENDIF – obdoba podmíněných bloků třeba u preprocesoru jazyka C.

.ifn výraz – .endif

Stejná konstrukce, jen obrácená podmínka: následující instrukce až do .ENDIF se překládají, pokud je výraz nulový!

BCD a přerušení

Už se blížíme ke konci, už vysvětluju to, co jsem průběžně odsouval…

Kód BCD (Binary Coded Decimal) je způsob zápisu desítkových čísel v šestnáctkové soustavě tak, že se místo znaků 0-F používají jen znaky 0-9 a když k 09h přičtete jedničku, nedostanete 0Ah, ale 10h. Odborné vysvětlení si můžete přečíst na Wikipedii (BCD), já se přiznám, že mi to moc jasné nebylo. Vezmu to tedy „vlastními slovy“.

Někdy se hodí vypsat číslice takovým způsobem, jakému rozumějí normální smrtelníci. Ti, jestli si ještě vzpomínáte, považují za číslice jen ty znaky od nuly do devítky, a kdybyste na ně vyrukovali s tvrzením, že A až F jsou taky číslice, tak vám nebudou rozumět. A ačkoli se někteří programátoři (pohříchu často vyrostlí na assembleru) domnívají, že člověk se má buď naučit rozumět počítačům tak, jak je přirozené strojům, nebo na ně nešahat a jít pracovat do marketingu, je převažující postoj opačný. Takže i v tom assembleru nezaškodí čas od času nasimulovat starou dobrou desítkovou soustavu.

Jestli jste si zkusili převést strojově osmibitové číslo na desítkovou hodnotu, dáte mi zapravdu, že to není úplně procházka růžovou zahradou. Dokonce ani počet bitů na číslici není vždy stejný… Proto vznikl kód BCD, kde se do jednoho osmibitového čísla vejde desítkové číslo z rozsahu 0 – 99. Pokud je číslo v kódu BCD, tak 99 (1001 1001) neznamená 153 desítkově, ale 99 desítkově.

Což, jako vyjádření čísla dobré, ale teď – jak se s tím pracuje? Procesor na to má nástroj.

Představte si, že sečtete dvě čísla, řekněme 13h a 28h. To máme 3Bh (je to totiž desítkově 19 + 40 = 59). A přesně to nám spočítá následující kód:

Pokud budeme obě čísla považovat za čísla v kódu BCD, tedy vlastně třináct a dvacet osm, budeme očekávat, že výsledek bude 41 – v BCD kódu 41h. Jak tedy sečíst dvě čísla v kódu BCD? Zcela normálně: sečteme je běžnou instrukcí ADD/ADI, a po ní použijeme instrukci DAA.

daa

znamená „Decadic Adjust after Addition“, neboli Desítková úprava po sčítání. Tahle instrukce vezme příznakové bity (zejména bit AC, který se nikde jinde nepoužívá) a pomocí nich upraví výsledek (3Bh) tak, aby byl v kódu BCD (41h).

Při odčítání platí

Požadavek na přerušení!

V procesorových systémech se občas stane něco významného a důležitého, na co je potřeba okamžitě zareagovat. Třeba někdo zmáčkne klávesu na klávesnici. (Aspoň vidíte, co je ve světě procesorů Opravdu Důležité – kdyby se náhodou vzňal a hořel, bylo by mu to jedno, ale zmáčknutý čudlík zasluhuje okamžitou reakci!) Nebo přijdou nějaké údaje ze sériového rozhraní a je třeba je přečíst, než tam někdo pošle další a tenhle se ztratí. Nebo se stane to, že uplyne nějaký předem nadefinovaný čas – tedy něco jako minutka na vaření vajíček. V takovém případě požádá to zařízení, které má výjimečnou událost, procesor o přerušení. Ten všeho nechá, odskočí si do podprogramu, který obslouží, co je potřeba, a pak se zase hezky vrátí zpátky k tomu, co měl rozdělané.

KONEC!

… to samé jako při sčítání. Stačí použít instrukci DAA, která upraví výsledek tak, aby zase obsahoval číslo v kódu BCD.

Po pravdě řečeno – s instrukcí DAA se člověk moc nesetkává. Kupodivu i spousta algoritmů na převod čísel z desítkové do šestnáctkové soustavy a zpátky se bez téhle instrukce obejde. Proto je to takový docela otloukánek, většinou ho vysvětlují všichni až na konci… kromě špatných knih o programování v assembleru x86, které probírají instrukce ne podle jejich složitosti nebo funkce, ale podle abecedy. Tam se totiž ta samá instrukce jmenuje AAA! Představte si, co byste říkali, kdybych na vás jako první instrukci vytáhnul právě DAA a BCD kód!

Požadavek na přerušení!

Přerušení je něco jako telefonát – taky vás zaskočí v nejnevhodnější chvíli a vy se mu musíte hned teď věnovat. Proto je dobré, aby jeho obsluha byla co nejkratší („Ano, pane řediteli! – Jistě pane řediteli! – Tak to jste se asi pos*al, pane řediteli! – Ano, na personální si dojdu zítra ráno! Nashledanou!“) Vyřídit to nezbytné, ať se můžeme vrátit k poctivé práci.

KONEC!

BCD kód bych, s dovolením, považoval tímto za probraný – ještě se k němu vrátíme v nějakých ukázkách algoritmů, ale víc už asi moc ne. Namísto toho se vypořádáme s přerušením…

di, ei

Jak přerušení vypadá, to jste názorně mohli vidět v předchozím textu. Naštěstí existují instrukce DI (ta přerušení zakáže) a EI (ta ho opět povolí). DI použijeme ve chvíli, kdy procesor potřebuje dodělat svou práci a je to důležitější než obsloužit periferie – třeba něco časově kritického. V zásadě by mohl mít zakázané přerušení neustále (a některé systémy to tak mají), ale zase na druhou stranu, když zůstanu u alegorie s telefonem: Nikdo se vám nedovolá!

Teď tedy používám jedno virtuální DI, aby už další výklad žádné přerušení nerušilo, a řekneme si, jak to vlastně funguje.

Procesor má vstup INT. Za normálních okolností by na něm měla být nula, a taky tam je. Pokud některá část počítače (klávesnice, sériový port, časovač, …) požaduje přerušení, nastaví příslušné obvody tento vstup na hodnotu 1. Procesor dokončí aktuální instrukci a zkontroluje stav tohoto vstupu. Když je 0, pokračuje dál, pokud je ale 1, a zároveň je přerušení povolené, udělá následující kroky:

1.     Zakáže přerušení

2.     Potvrdí, že požadavek převzal (tj. ve stavovém slovu pošle informaci INTA – Interrupt Acknowledge)

3.     Přečte z datové sběrnice kód instrukce, kterou má vykonat. Je to jedna z instrukcí RST0-RST7, nebo instrukce CALL.

4.     Načtenou instrukci pak provede.

Všimněte si, že jsem nepsal, že ji čte „z paměti“, ale „ze sběrnice“. Je na systému, aby v takovém stavu připravil procesoru tu správnou instrukci.

Asi nejjednodušší způsob, který lze dosáhnout zapojením jednoho odporu, je ten, že vždy, když procesor vyšle INTA a čeká na instrukci, tak mu pomocný obvod 8228 vrátí RST 7. Vzpomeňte si, co jsme si říkali o instrukci RST n: Je to volání podprogramu na adrese 8*n. RST 7 tedy zavolá podprogram na adrese 38h a tam by měla proběhnout obsluha přerušení.

Složitější způsoby, které využívají třeba obvod 8214, dokážou obsloužit osm různých požadavků podle jejich priorit a adekvátně k nim zavolat různé instrukce RST. Specializované řadiče přerušení (8259) dokážou například cyklicky měnit priority nebo volat ne osm pevně daných instrukcí, ale pomocí instrukce CALL zavolat libovolnou adresu.

Ale u těch jednodušších systémů je většinou vše zapojeno tak, že INT znamená vykonání instrukce RST 7.

Obslužná rutina by měla být co nejkratší a nejrychlejší. Nezapomeňte na konci zase povolit přerušení instrukcí EI, jinak obsluha proběhne jen jednou. A pokud náhodou budete psát obsluhu přerušení pro různé RST, uvědomte si, že na to máte jen osm bajtů – nejčastěji ty první tři použijete pro JMP a pět zůstane volných.

hlt

Víte, co dělá procesor v počítači většinu času? Čeká. Čeká, až mu něco řeknete, pak to chvíli zpracovává, a pak zase čeká. Mezi zmáčknutím kláves čeká. Když zmáčknete dvě klávesy za sekundu, tak za tu dobu provede 8080A rovné dva miliony taktů. Obsluha každého zmáčknutí zabere, no, ať nežeru, i třeba 500 taktů! Procesor tedy 1000 taktů pracoval a 1 999 000 taktů jen čekal, jestli se nestane něco zajímavého. Váš den, kdybyste byli procesor, by vypadal tak, že byste 43 sekund dělali něco zajímavého, a zbývajících 23 hodin 59 minut a 17 sekund by se nedělo nic. Vůbec nic. (A tohle jim děláme neustále, mimochodem!)

Instrukce HLT zastaví procesor. Stojí na místě, neděje se nic, žádné instrukce neprovádí, zkrátka stojí. Stojí a stojí. Nic nedělá. Šmitec, šlus, finito. Z téhle letargie ho probudí buď RESET, nebo právě požadavek na přerušení. Představte si, jak ten procesor zpracovává instrukci HLT, stojí stále na místě, jakoby v nekonečné smyčce, když v tom přijde požadavek na přerušení. Procesor udělá ty kroky, které jsem popsal a provede (třeba) instrukci RST 7. Ta vykoná nějaké operace a vrátí se za instrukci HLT. Program tak může pokračovat. Často se tenhle fígl používá např. k tomu, že si nastavíme časovač (onu „minutku“) a procesor pomocí HLT zastavíme. Až doběhne požadovaný časový interval, přijde přerušení, a to nás vyvede ze stavu HALT.

Sledujte: HLT!

Instrukce 8080 – práce s periferiemi

Pracovat s pamětí je fajn, ale pro uživatele je paměť neviditelná. Uživatel ocení třeba nějaké to písmeno na displeji, nějaký ten zvuk, chce zmáčknout tlačítko, zakvrdlat joystickem či tak něco…

Počítačové periferie jsou „všechno co není procesor nebo paměť“. Takže třeba ty klávesnice, výstupní zařízení, magnetofony, reproduktory, … Ty se nějakým způsobem připojují do systému (jakým přesně, to záleží na tvůrci systému) a procesor s nimi komunikuje.

Některé procesory (6502 například) nerozlišují periferie od paměti. Zkrátka a dobře určité adresy z adresního rozsahu neobsadí paměť, ale periferie. „Pošli znak 12 sériovou linkou“ je pro ně stejná operace jako „ulož znak 12 do paměti na konkrétní adresu“. Má to svoje výhody, ale i nevýhody.

Procesor 8080 (nebo Z80) naproti tomu mají speciální vývody, které říkají: Teď se nepřistupuje do paměti, ale ke vstupně-výstupnímu zařízení, k periferii. Paměť může zůstat neaktivní a adresa čtení nebo zápisu se vztahuje na periferní zařízení (je pro to takové slovo „port“ – „přistupujeme na porty“ třeba). U procesoru 8080 může být až 256 periferních zařízení, protože pro tyto operace používá osmibitovou adresu.

in, out

Procesor 8080 má dvě instrukce pro práci s periferiemi. IN slouží ke čtení, OUT k zápisu. Obě instrukce mají jeden přímý parametr, a tím je osmibitová adresa periferie. Instrukce IN F8h přečte bajt z periferie na adrese F8h a uloží ho do registru A. OUT 23h vezme obsah registru A a pošle ho na periferii na adresu 23h.

Víc k těmto instrukcím asi nelze říct. Jsou opravdu tak jednoduché, jak vypadají. Konkrétní adresy už jsou na tvůrci toho kterého systému.

Například v počítači PMI-80 je na adresách F8h-FBh připojen obvod 8255, který slouží jako programovatelný obvod pro řízení vstupů a výstupů. Tentýž obvod v PMD-85 sídlí na adresách F4h-F7h (a tam obsluhuje klávesnici, LED a reproduktor), další stejného typu je na adresách F8h-FBh (a tam se stará o načítání dat z ROM modulu), no a na adresách 1Eh a 1Fh je připojený obvod 8251, který pro změnu slouží pro komunikaci s kazetovým magnetofonem.

Ostatně, když už jsem zmínil klávesnici…

Když jsem v minulém dílu psal o tom, že stisk klávesy vyvolá přerušení, tak, po pravdě řečeno, spíš ne… Totiž, ne že by to nešlo, ne že by to nebyl dobrý nápad, ale v dobách největšího rozmachu osmibitů snad žádný z nich nepoužíval přerušení při stisku klávesy (vzpomínám jen na jednu zvláštnost, a tou byla konstrukce klávesnice z nějakého Amatérského Rádia, která vyvolala přerušení při stisku klávesy). Naprostá většina systémů v té době používala zcela jiný princip.

Klávesy na klávesnici se zapojovaly do matice N x M, kdy každá klávesa sídlila v nějakém průsečíku. Jedno z těchto čísel bylo často 8, aby se líp připojovala k periferním obvodům. Například klávesnice u ZX Spectra byla organizovaná do 8 řádků po 5 sloupcích. Řádky byly připojeny na vstupní port (s klidovým stavem 1), sloupce na výstupní. Když chtěl programátor vědět, jaká klávesa je stisknuta, poslal postupně 0 na jednotlivé vodiče sloupců a pokaždé si přečetl hodnotu řádků. Pokud byly všude 1, znamenalo to, že v tom sloupci není žádná klávesa stisknuta, když našel 0, věděl, že našel nějakou stisknutou klávesu.

U jednodeskových počítačů platilo totéž. Stejně byla zapojena klávesnice PMI-80, PMD-85, IQ-151 a dalších. U Atari 800 třeba taky, ale tam se o tohle testování stisknuté klávesy nestaral procesor, ale specializovaný obvod POKEY. U Commodore C64 byla rovněž matice a specializovaný obvod CIA.

Některé osmibitové počítače, zejména jednodeskové, měly jako displej nejrůznější sedmisegmentovky. Ty se většinou připojovaly přes nějaký port. U počítače BOB-85 měly dokonce i latche, tj. „paměti“ aktuálního stavu; naopak u PMI-80 bylo potřeba postupně vysílat informace o tom, co se má na které sedmisegmentovce zobrazovat. Displej byl připojen podobně jako klávesnice a během čtení jednotlivých sloupců se také rozsvěcely jednotlivé sedmisegmentovky…

Displeje u „větších“ počítačů byly řešeny buď jako znakové (IQ-151, SAPI-1), nebo grafické (PMD, Spectrum, …) – některé systémy měly inteligentní řadiče, které se dokázaly přepnout do různých módů. Ať tak či onak, většinou se k displeji přistupovalo jako k paměti (přesněji řečeno: řadič displeje si sahal do vyhrazené oblasti v paměti RAM a zobrazoval odtamtud data).

Konec? Ani náhodou!

V tomto místě jsme skončili s přehledem instrukcí procesoru 8080. Jenže v assembleru víc než v jiném jazyce platí: mýlí se ten, kdo zaměňuje znalost jazyka za znalost jeho příkazů. Takže nebojte, zanedlouho se zase setkáme a budeme pokračovat. Ukážeme si, jak v assembleru řešit nějaké úlohy, a hlavně: máme před sebou ještě minimálně dva procesory!

Instrukce 8080 – přehledně v jedné tabulce

Tak si to shrňme, ano?

ZOBRAZ ZÁZNAMŮ 10162550100

HLEDAT:

Zobrazuji 1 až 16 z celkem 256 záznamů

PředchozíDalší

No related posts.

Trocha assemblerové teorie

Tuhle jsem do rozhovoru pro programátorský magazín (ve skutečnosti Zdroják) říkal: ASM80 je dvouprůchodový assembler. Prý to mám vysvětlit, co to znamená…

V dobách osmibitů byl „dvouprůchodový assembler“ de facto standard. Ale co to znamená? Musíme si říct, jak vlastně překladač funguje.

Bere řádek po řádku a kouká se, jestli tam je instrukce nebo pseudoinstrukce. Pokud ano, začlení si její kód do připravovaného výsledného útvaru, popř. provede to, co pseudoinstrukce nařizuje. Tím, že už v téhle fázi připravuje kód, tak vlastně ví, jak dlouhá která instrukce bude. Takže si může průběžně vytvářet i tabulku adres, kde má ke každému symbolickému jménu uloženou jeho adresu (nebo hodnotu). To je první průchod.

Ve druhém průchodu tohle všechno už má připravené, takže jede znovu, a jen na místech, kde je potřeba vyčíslit nějakou konkrétní hodnotu s odkazem, spočítá jeho hodnotu a doplní do kódu.

Takhle tedy funguje ASM80. Fungoval stejně i GENS (např.) Něco podobného (podobného!) dělal i Prométheus, ale ten, nakolik jsem pochopil, dělal část prvního průchodu už při editaci textu, kdy si jednotlivé instrukce „předpřekládal“.

Co jiné počty průchodů? Tříprůchodový? Jasně, existují. Dokážou třeba vyřešit problém několikanásobné dopředné reference, navíc by mohly trošku optimalizovat (plné skoky nahradit relativním, dlouhé varianty instrukcí těmi se zero page u 6502 a podobně).

Šel by napsat jednoprůchodový assembler? No jasně, šel – představte si první průchod, při něm to vyhodnocování výrazů… Když narazí na adresu, kterou už zná, tak ji použije, když ji ale ještě nezná, zapíše si do tabulky symbolických názvů tenhle název s poznámkou: „Až na tohle návěští narazím, doplním ho tam a tam“.

Počet průchodů tedy dokáže ovlivnit některé aspekty chování překladače (dopředné reference by jednoprůchodový zvládnul).

A kolikaprůchodové se používají dneska?

Turbo assembler, poslední, který jsem na PC platformě používal, je „multiprůchodový“. Ale vzhledem k jeho komplexnosti to ani jinak nejde. Ten hlavní rozdíl proti „starým pákám“ je v tom, že assembler dneska (ani včera) nepřipraví hotový binární kód pro spuštění. Sestaví něco, čemu se říká „objektkód“, což je v podstatě výsledek posledního průchodu, ale nevadí mu, když nějaké adresy nerozpoznal. Pravděpodobně patří nějaké knihovní rutině. Objektkód pak dostane do spárů program, kterému se říká „linker“, a ten spojí vše potřebné – všechny části kódu, knihovní rutiny, data, vše. Teprve když tady nějaký symbol chybí, tak je zle. Překladač oddělený od linkeru má tu výhodu, že program může být napsaný v různých jazycích, v jednom třeba výpočty, v druhém UI, knihovny ve třetím – a linker to poslepuje dohromady. Toto rozdělení samozřejmě není nijaká novinka. Není to dokonce ani výmysl šestnáctibitového světa. I osmibity měly překladače a linkery zvlášť, např. u CP/M. Tohle rozdělení funguje tam, kde není problém pracovat se soubory. U osmibitového domácího počítače s kazeťákem by to moc smysl nedávalo.

8080 – algoritmy 1

Algoritmy! Neseme čerstvé algoritmy! Berte, paní, jsou zadarmo a přitom tak užitečné!

přesun bloku dat

Máme 32 bajtů na nějaké adrese a chceme je zkopírovat na adresu úplně jinou. Jak na to? Jednoduše – použijeme instrukci LDIR a… cože? Ajo vlastně, instrukci LDIR má až procesor Z80, u 8080 nic takového není, tam si to musíme pořešit jináč. Třeba takhle:

Nejprve si naplním registry patřičnými údaji – do registrů HL dám adresu, kde se blok dat nachází, do registrů DE adresu, kam chci blok přesunout, do registrů BC počet bajtů, které chci přesunout. Ve smyčce LDIR (která se víceméně chová shodně s instrukcí LDIR procesoru Z80, až na to, že tady je pomalejší a přepisuje obsah registru A) se děje následující: Do registru A vezmu bajt z adresy HL, uložím ho na adresu DE, obě adresy zvýším o 1, od počítadla BC odečtu jedničku, a když je BC nenulové, opakuju smyčku.

Bohužel (tedy někdy spíš bohudík) instrukce INX, DCX nemění stav příznaků. Což je dobře, jak uvidíme v dalších algoritmech, ale v případě, jako je tento, by se nám hodilo, kdyby DCX dokázala nastavit příznak Z, jako že je výsledek nula. Ale nedělá to, takže si to musíme vyřešit jinak (zvykejte si, to je assembler!)

Každý podobný případ lze řešit několika způsoby, ale časem se ustálí vždy jeden návrhový vzor, který má nejméně nevýhod. V případě „zkontroluj, jestli je ve dvojici registrů 0“ se používá ten, který jsem ukázal v kódu: do A si zkopíruju jeden registr z dvojice, udělám OR s druhým (vzpomeňte – výsledkem OR je nula, pokud všechny bity obou operandů jsou nulové) – a protože OR už příznakový bit Z změní podle výsledku, tak jsme získali, co jsme chtěli.

Jak bychom to ale řešili, kdyby v A bylo něco, co chceme zachovat? Řešit by to samosebou šlo, jen – jinak a náročněji.

přepsání bloku dat

V procesoru Z80 se instrukce LDIR používá i k jiné operaci, než je přesun bloků dat – totiž k mazání (přesněji k nastavení celého bloku na konkrétní hodnotu). Využívá se toho, že nastavíme registry HL a DE určitým způsobem – HL na začátek bloku, který se má smazat, DE na adresu o 1 vyšší. Ručně pak nastavíme první bajt bloku (ten, kam ukazuje HL) na požadovanou hodnotu a LDIR postupně první bajt bloku nakopíruje na další a další adresy. BC je v takovém případě (délka bloku – 1). Pokud nastavíme DE na adresu větší než HL+1, třeba HL+4, vyplní LDIR blok paměti vzorkem dat (HL, HL+1, HL+2, HL+3).

Fungovalo by to i s tím naším LDIRem? Ale určitě fungovalo, jen je to v případě nastavení nějaké oblasti v paměti na konkrétní hodnotu trošku kanón na vrabce (a to v assembleru znamená vždy: stojí to paměť a čas). Jednodušší postup je zde:

Všimněte si, že hodnota, která se do bloku paměti zapisuje, není v registru A, ale v registru E. Je to právě kvůli výše popsanému postupu na testování BC na nulu – využívá registr A. Kdybychom v něm měli tu hodnotu, přepsali bychom si ji. Abychom si ji nepřepsali, museli bychom si ji někam uložit (pravděpodobně třeba do toho registru E), pak zase načíst zpátky… Výsledek by byl sice funkční, ale pomalejší a delší. A to jen kvůli tomu, že chceme číslo v jiném registru?! Kdepak.

dělení

Tuhle jsme si ukazovali, jak násobit dvě celá čísla bez znaménka. Dělení můžeme napsat analogicky – buď jako postupné odčítání, nebo pomocí rotací a odčítání. Ten druhý postup opět můžeme napsat bez triků, nebo s trikem…

Tady je postup pro dělení dvojregistru HL registrem D. Matematicky: HL = HL / D, zbytek po dělení je v registru A. Je to postup s trikem (používá se „trojitý registr“ AHL, do A se postupně nasouvají bity z HL a kontroluje se, jestli už je mezistav větší než dělitel).

Ukázali jsme si pár triků a předvedli pár algoritmů. Ovšem v programování obecně a pro assembler zvlášť platí, že:

1. Není důležité si tyhle algoritmy pamatovat, důležitější je umět je napsat, když je potřeba

2. Je dobré si tyhle algoritmy pamatovat, aby je člověk nepsal zbytečně znovu

3. Nejdůležitější je dokázat se rozhodnout, jestli pro daný konkrétní případ platí 1 nebo 2!

Instrukce 6502 v jedné tabulce

ZOBRAZ ZÁZNAMŮ 10253250100

HLEDAT: