Instrukční sada AArch64

Obsah

1. Instrukční sada AArch64

2. Operační kódy instrukcí

3. Instrukce typu Load-Store

4. Load-Store pro dvojici registrů

5. Nepodmíněné skoky a skoky do subrutiny (branch and link)

6. Podmíněné skoky

7. Základní aritmetické instrukce

8. Násobení a dělení

9. Logické instrukce

10. Znaménkové rozšíření operandu či rozšíření o nuly

11. Aritmetické a bitové posuny, bitová rotace

12. Podmíněné zpracování dat

13. Podmíněný výběr operandu

14. Další instrukce s podmínkou

15. Extrakce dat

16. Odkazy na Internetu

1. Instrukční sada AArch64

Na předchozí článek s popisem 64bitových mikroprocesorů s architekturou AArch64 dnes navážeme, protože se budeme věnovat podrobnějšímu popisu instrukční sady. Zaměříme se spíše na zajímavější a z pohledu jiných ISA i neobvyklé instrukce a nezapomeneme ani zdůraznit význam „nulového“ registru WZR/XZR, díky jehož existenci vzniklo velké množství užitečných instrukční aliasů. Zopakujme si však nejprve seznam typů instrukcí, který je pro účely dnešního článku nepatrně rozšířen:

2. Operační kódy instrukcí

Všechny instrukce mají pevnou šířku třiceti dvou bitů. Těchto 32 bitů je rozděleno do jednotlivých bitových polí, v jejichž uspořádání je možné nalézt určitou pravidelnost. Mnoho instrukcí používá takzvaný tříadresový kód, v němž se pěti bity určuje první zdrojový registr, dalšími pěti bity druhý zdrojový registr a další pětice bitů určuje index cílového registru. Zajímavé je, že u některých instrukcí nejsou všechny bity instrukčního slova využity (alespoň prozatím), naproti tomu například u skokové instrukce B je většina bitů použita pro uložení adresy:

000x 01ii iiii iiii iiii iiii iiii iiii

Pro příklad se podívejme na způsob zakódování těchto dvou instrukcí:

add     x1, x1, #0x1
sub     x2, x2, #0x1

První z těchto instrukcí má kód:

0x91000421

Druhá z těchto instrukcí má kód:

0xd1000442

Při převodu do binární soustavy získáme kódy:

1001 0001 0000 0000 0000 0100 0010 0001
1101 0001 0000 0000 0000 0100 0100 0010

Zapišme si tyto kódy společně s maskami obou instrukcí:

x00x 0001 SSii iiii iiii iinn nnnd dddd
1001 0001 0000 0000 0000 0100 0010 0001
 
x10x 0001 SSii iiii iiii iinn nnnd dddd
1101 0001 0000 0000 0000 0100 0100 0010

„Luštění“ je relativně snadné:

x00x 0001 SSii iiii iiii iinn nnnd dddd
 
1001 0001 0000 0000 0000 0100 0010 0001
                                 ^ ^^^^
                                 dest=x1
                                 (5 bitů)
 
1001 0001 0000 0000 0000 0100 0010 0001
                           ^^ ^^^
                           src=x1
                          (5 bitů)
 
1001 0001 0000 0000 0000 0100 0010 0001
            ^^ ^^^^ ^^^^ ^^
            immediate=0x01
              (12 bitů)
 
1001 0001 0000 0000 0000 0100 0010 0001
          ^^
          shift=0x00 (konstanty)
          (4 bity)
 
1001 0001 0000 0000 0000 0100 0010 0001
 ^^  ^^^^
kód instrukce

Podobné tomu bude i u instrukce SUB, kde se ovšem pracuje s registrem X2 a horní čtyři bity budou taktéž odlišné.

3. Instrukce typu Load-Store

Jak je u RISCové architektury obvyklé, nalezneme v instrukční sadě i několik instrukcí určených pro načítání dat z paměti do registrů a naopak pro ukládání obsahu registrů do paměti. Navíc některé instrukce umožňují práci nejenom s 32bitovými a 64bitovými slovy, ale i s menšími bloky dat – s bajty a šestnáctibitovými „půlslovy“:

Poznámka: zdánlivě chybějící instrukce LDRW a STRW jsou již obsaženy v základních instrukcích LDR a STR, pokud použijeme 32bitový registr (u LDR se horních 32 bitů vynuluje).

Mezi podporované adresovací režimy patří i použití offsetu vůči vybranému registru či SP.

4. Load-Store pro dvojici registrů

Již v předchozím článku jsme si řekli, že u čipů s instrukční sadou AArch64 nenalezneme instrukce LDM (Load Multiple) a STM (Store Multiple), které dokážou načíst nebo uložit libovolnou skupinu až šestnácti registrů specifikovaných bitovým polem (ovšem v určeném pořadí). Naproti tomu však máme k dispozici instrukce pro načtení páru registrů, přičemž se může jednat o libovolné registry (nemusí být uloženy za sebou atd.). Zajímavé je, že u těchto instrukcí existují dvě varianty, které dávají CPU informaci o tom, zda se jedná o dočasné (temporary) úložiště (zásobníkový rámec atd.) či spíše o trvalejší uložení dat. Tuto informaci je možné použít pro řízení přístupu ke cache atd.:

5. Nepodmíněné skoky a skoky do subrutiny (branch with link)

U instrukční sady AArch64 je zajímavé (a současně i velmi užitečné), že základní skoková instrukce B neprovádí skok na zadanou absolutní adresu, ale na adresu relativní vůči aktuální hodnotě PC. Rozsah skoku je v takovém případě ±128 MB; větší konstantu není možné v dané konfiguraci instrukčního slova uložit. Dále pak instrukční soubor obsahuje instrukci pro skok do podprogramu s uložením návratové adresy do registru X30 (nikoli na zásobník, používáme RISCový čip) a skok na absolutní adresu uloženou ve vybraném registru. Tato instrukce existuje ve dvou variantách, které se od sebe odlišují pouze hintem pro CPU, zda se právě realizuje návrat z podprogramu (subrutiny) či obyčejný skok:

6. Podmíněné skoky

Jak jsme se již dozvěděli v předchozí části tohoto seriálu, je instrukční sada AArch64 hned v několika ohledech odlišná od původní 32bitové RISCové instrukční sady ARM32 (či zkráceně pouze A32). Zásadní a na první pohled viditelná odlišnost spočívá v tom, že se zredukoval počet těch strojových instrukcí, u nichž je možné použít podmínkové bity. Jen ve stručnosti si připomeňme, že v instrukční sadě ARM32 jsou v každém instrukčním slovu (každé má bez výjimky konstantní šířku třiceti dvou bitů) rezervovány čtyři nejvyšší bity, v nichž je zapsán kód podmínky, při jejímž splnění se instrukce provede. Díky této vlastnosti bylo možné v mnoha algoritmech zredukovat počet podmíněných skoků, což je v případě (dnes už nejenom) RISCových procesorů poměrně důležité.

Obrázek 1: Formáty instrukčních slov u původní 32bitové architektury ARM. Povšimněte si, že v každém instrukčním slovu jsou nejvyšší čtyři bity vyhrazeny pro uložení kódu podmínky.

Všechny podmínky jsou vyhodnoceny na základě hodnoty jednoho či (častěji) kombinací většího množství příznaků (flags). První sada podmínkových kódů se používá pro provedení či naopak neprovedení instrukce na základě hodnoty jednoho z příznakových bitů Z (zero), V (overflow) či N (negative). Poslední podmínkový kód z této skupiny má název AL (Any/Always) a značí, že se instrukce provede v každém případě. Tento podmínkový kód se tudíž většinou v assembleru ani nezapisuje, protože je považován za implicitní:

Další čtyři podmínkové kódy se většinou používají při porovnávání dvou celých hodnot bez znaménka (unsigned integer). V těchto případech se testují stavy příznakových bitů C (carry) a Z (zero), přesněji řečeno kombinace těchto bitů:

Poslední čtyři podmínkové kódy se používají pro porovnávání hodnot se znaménkem (signed). V těchto případech se namísto příznakových bitů © carry a (Z) zero testují kombinace bitů (N) negative, (V) overflow a (Z) zero:

Procesory s architekturou AArch64 sice používají shodné podmínkové bity, ty jsou ovšem použity jen v několika pečlivě vybraných instrukcích. Příznak přetečení je, podobně jako u mnoha dalších typů procesorů, používán při aritmetických operacích (ovšem ne implicitně – jen u instrukcí končících na S – set) a testy podmínkových bitů lze provádět především u podmíněných skoků, tj. u instrukcí, jejichž mnemotechnická zkratka začíná znakem B od slova „Branch“. Rozeznáváme následující typy nepodmíněných podmíněných skoků:

Poznámka: alternativní zápis je podporován například GNU Assemblerem, většinou však můžete používat obě varianty zápisu.

Další dva typy skoků jsou odvozeny od instrukcí, které známe z instrukční sady Thumb. Dochází zde k porovnání vybraného pracovního registru s nulou:

Existují ještě další dvě instrukce pro podmíněné skoky, které se jmenují TBZ (Test and Branch if Zero) a TBNZ (Test and Branch if Not Zero). Ty provádí test hodnoty vybraného bitu registru na nulu:

Způsob zápisu těchto instrukcí je následující:

TBZ  Xn, #konstanta, návěští
TBZ  Wn, #konstanta, návěští
TBNZ Xn, #konstanta, návěští
TBNZ Wn, #konstanta, návěští

Konstanta má šířku pouze šest bitů, protože je v ní uložen index bitu pracovního registru, který se testuje na nulu či jedničku (u registrů Wn by stačilo jen pět bitů). V případě instrukce TBZ – pokud je n-tý bit registru Xn/Wn nastavený na nulu, provede se skok, v opačném případě se řízení přenese na další instrukci. V případě instrukce TBNZ je bit testován na jedničku. Vzhledem k tomu, že v instrukčním slovu je nutné kromě adresy cíle (návěští) specifikovat i číslo pracovního registru a index bitu, je tento typ skoku omezen na rozsah ±32kB, což by ovšem v praxi mělo být více než dostačující (v opačném případě lze TBZ/TBNZ zkombinovat s absolutním skokem B).

7. Základní aritmetické instrukce

Mezi základní aritmetické instrukce samozřejmě patří součet a rozdíl. Existují vždy čtyři varianty každé z těchto operací, které se od sebe liší podle toho, zda se při výpočtu nastavují příznaky (všechny čtyři) a zda se po součtu či rozdílu ještě k výsledku přičte předchozí hodnota příznaku carry:

Kromě toho existuje hned několik instrukčních aliasů, které je možné používat v assemblerech a které jsou rozpoznány i v disassemblerech a debuggerech. Tyto aliasy využívají registr WZR (32 bitů) či XZR (64 bitů). Připomeňme si, že tento registr je při čtení vždy nulový, což je v tomto případě výhodné, protože vlastně zadarmo získáme velké množství užitečných instrukcí:

Poznámka: v praxi se setkáte především s aliasy CMP, CMN a hlavně pak MOV (resp. přesněji řečeno je toto jedna z mnoha variant pseudoinstrukce MOV).

8. Násobení a dělení

U čipů AArch64 nalezneme násobičku a děličku, která dokáže vynásobit jak 32bitové, tak i 64bitové operandy. Mezi podporovanými instrukcemi najdeme i obdobu DSP instrukcí Multiply-Accumulate, ovšem s tím rozdílem, že se namísto akumulátoru může použít odlišný vstupní a odlišný výstupní registr, což konkrétně znamená, že DSP operace:

acc += op2 × op3

dokáže AArch64 provést:

op1 = op2 × op3 + op4

Podívejme se nyní, které instrukce provádí násobička a dělička:

Poznámka: ve skutečnosti je instrukce MUL, tedy „běžné násobení“ aliasem pro instrukci MADD, v níž je třetím vstupním operandem registr WZR či XZR, tedy „konstantní nula“. Totéž platí pro instrukci MNEG, která vznikla z instrukce MSUB, u níž je opět posledním vstupním operandem nulový registr.

9. Logické instrukce

Nesmíme samozřejmě zapomenout ani na instrukce pro provedení logických operací. Nalezneme zde klasickou trojici instrukcí pro logický součin bit po bitu, logický součet bit po bitu i logickou nonekvivalenci a navíc i instrukce, v nichž je druhý vstupní operand negován. Navíc se u všech instrukcí možné druhý operand i posunout o konstantu uloženou v instrukčním slovu:

Povšimněte si, že pouze instrukce ANDS nastavuje příznaky.

Podobně jako u aritmetických operací, i u operací logických lze využít registru WZR a XZR pro vytvoření instrukčních aliasů, například druhého aliasu MOV (první byl implementován přes ADD), instrukce MOVI (načtení malé konstanty) a zejména pak užitečné pseudoinstrukce TST známé i z dalších architektur:

10. Znaménkové rozšíření operandu či rozšíření o nuly

Některé instrukce slouží k manipulaci se šestnáctibitovými konstantami, které se musí nějakým způsobem rozšířit na konstanty 32bitové a 64bitové. Jedná se o následující trojici instrukcí, které vždy obsahují jak již zmíněnou šestnáctibitovou konstantu, tak i druhou konstantu reprezentující posun doleva:

Poznámka: při práci v assembleru většinou stačí použít pseudoinstrukci MOV, kterou assembler sám dokáže rozložit na ty instrukce, které CPU skutečně dokáže zpracovat.

Další šestice instrukcí dokáže provést znaménkové či naopak bezznaménkové rozšíření bajtu, šestnáctibitového slova (u AArch64 se používá termín halfword) či 32bitového slova (word) na 64bitovou hodnotu. Bezznaménkové rozšíření pouze vynuluje horní bity registru:

11. Aritmetické a bitové posuny, bitová rotace

Množina instrukcí navržených pro provedení operací aritmetického či bitového (logického) posunu je celkem přehledná. Povšimněte si navíc poslední instrukce ROR určené pro bitovou rotaci. Neexistuje zde rotace vlevo, protože ta samozřejmě odpovídá rotaci vpravo, ovšem o odlišnou hodnotu (odečtenou od 63 či 31):

U všech předchozích instrukcí byl posun specifikován konstantou, zatímco u dalších čtyř instrukcí je posun uložen v registru (druhý vstupní operand). Hodnota tohoto registru však není použita přímo, protože se v úvahu bere jen posledních pět či šest bitů podle toho, zda se jedná o 32bitovou či 64bitovou operaci:

Poznámka: instrukce ROR je ve skutečnosti aliasem instrukce EXTR popsané v patnácté kapitole.

12. Podmíněné zpracování dat

V této kapitole se seznámíme s následujícími instrukcemi:

První zcela novou instrukcí uvedenou až na architektuře AArch64, je instrukce nazvaná CSET neboli Conditional Set. Tato instrukce vlastně přímo odpovídá požadavkům kladeným na datový typ boolean v mnoha programovacích jazycích, v nichž je hodnota true interně reprezentována jedničkou a hodnota false nulou. Tato instrukce existuje ve dvou variantách, přičemž první varianta pracuje s 32bitovým a druhá varianta s 64bitovým operandem):

CSET Wd, condition
CSET Xd, condition

Například:

CSET W3, EQ
CSET W4, MI
CSET X5, HI

Tato instrukce pracuje následujícím způsobem – v případě, že je podmínka zapsaná ve druhém operandu cond splněna, uloží se do cílového registru Wd či do registru Xd hodnota 1. Pokud podmínka naopak splněna není, uloží se do registru Wd či Xd hodnota 0:

cíl = condition ? 1 : 0;

Ve skutečnosti se v případě CSET jedná o alias pro instrukci CSINC popsanou dále (podmínka ovšem musí být v tomto případě negována):

CSINC Wd, WZR, WZR, invert(condition)
CSINC Xd, XZR, XZR, invert(condition)

neboli:

cíl = invert(condition) ? 0 : 0+1;

Opět zde tedy využíváme vlastnosti registru WZR a XZR.

V některých případech je však nutné ukládat pravdivostní hodnoty odlišným způsobem – true bude reprezentováno hodnotou, v níž jsou všechny bity 32bitového či 64bitového slova nastaveny na jedničku (v případě celých čísel se znaménkem to odpovídá hodnotě –1), false naopak hodnotou, v níž jsou všechny bity nulové. V tomto případě lze pro nastavení namísto CSET použít instrukci CSETM:

CSETM Wd, condition
CSETM Xd, condition

Ve vyšším programovacím jazyce by bylo možné napsat:

cíl = condition ? -1 : 0;

Poznámka: u 32bitového registru odpovídá –1 hodnotě 0×ffff ffff, u 64bitového registru pak hodnotě 0×ffff ffff ffff ffff.

Opět se v tomto případě jedná o aliasy, tentokrát ovšem na instrukci CSINV:

CSINV Wd, WZR, WZR, invert(condition)
CSINV Xd, XZR, XZR, invert(condition)

Poznámka: slovo „mask“ v názvu instrukce skutečně poměrně přesně odpovídá jednomu způsobu použití, protože pokud platí true=-1 a false=0, lze s těmito hodnotami provádět logický součin a součet bit po bitu, a to i v případě, kdy je druhým operandem odlišná hodnota.

13. Podmíněný výběr operandu

Mezi další instrukce, v nichž se vyhodnocuje podmínka, patří:

Užitečnou instrukcí s podmínkou je instrukce zapisovaná mnemotechnickým kódem CSEL neboli Conditional Select. I tato instrukce existuje ve dvou variantách – 32bitové a 64bitové:

CSEL Wd, Wn, Wm, condition
CSEL Xd, Xn, Xm, condition

Tato instrukce pracuje následovně: pokud je podmínka splněna, uloží se do cílového registru Wd či Xd hodnota z prvního zdrojového registru Wn nebo Xn. Pokud podmínka splněna není, je do cílového registru Wd/Xd uložena hodnota z druhého zdrojového registru Wm/Xm.

Instrukce CSEL tedy nahrazuje programovou konstrukci typu:

cíl = condition ? zdroj1 : zdroj2;

Alternativní formou instrukce CSEL je instrukce CSINV neboli Conditional Select Invert:

CSINV Wd, Wn, Wm, condition
CSINV Xd, Xn, Xm, condition

Tato instrukce pracuje následovně: pokud je podmínka splněna, uloží se do cílového registru Wd či Xd hodnota z prvního zdrojového registru Wn nebo Xn. Pokud podmínka splněna není, je do cílového registru Wd/Xd uložena negovaná hodnota přečtená z druhého zdrojového registru Wm/Xm.

Instrukce CSINV tedy nahrazuje programovou konstrukci typu:

cíl = condition ? zdroj1 : ~zdroj2;

Poznámka: znak ~ je používán v programovacím jazyku C a od něj odvozených jazycích pro zápis unárního operátoru negace všech bitů (jedničkový doplněk).

Zajímavá je instrukce CSINC, která kombinuje možnosti instrukce CINC a CSEL:

CSINC Wd, Wn, Wm, condition
CSINC Xd, Xn, Xm, condition

Tato instrukce provádí následující činnost:

Wd = condition ? Wn : Wm+1;
Xd = condition ? Xn : Xm+1;

Touto instrukcí realizována již popsaná pseudoinstrukce CSET, a to tehdy, pokud jsou oba zdrojové registry nulové (WZR a XZR). V tomto případě se do cílového registru dosadí 0 či 0+1=1:

CSINC Wd, WZR, WZR, invert(condition)
CSINC Xd, XZR, XZR, invert(condition)

Instrukce nazvaná CSNEG se do jisté míry podobá instrukci CSINV, ovšem s tím rozdílem, že se namísto jedničkového doplňku (negace) používá při nesplnění podmínky dvojkový doplněk:

CSNEG Wd, Wn, Wm, condition
CSNEG Xd, Xn, Xm, condition

Tato instrukce pracuje následovně: pokud je podmínka splněna, uloží se do cílového registru Wd či Xd hodnota z prvního zdrojového registru Wn nebo Xn. Pokud podmínka splněna není, je do cílového registru Wd/Xd uložena hodnota přečtená z druhého zdrojového registru Wm/Xm, u které se nejdříve změní znaménko (onen zmíněný dvojkový doplněk).

Tato instrukce tedy nahrazuje programovou konstrukci typu:

cíl = condition ? zdroj1 : -zdroj2;

14. Další instrukce s podmínkou

Poslední tři instrukce ze sady AArch64, v nichž se vyhodnocuje podmínka, jsou vypsány v tabulce pod tímto odstavcem:

Instrukce CINC je aliasem pro instrukci CSINC, ovšem s převrácenou podmínkou a shodnými zdrojovými registry:

CINC Wd, Wn, condition
CINC Xd, Xn, condition

Tato instrukce provádí následující činnost (je zde jen jediný zdrojový registr):

Wd = condition ? Wn+1 : Wn;
Xd = condition ? Xn+1 : Xn;

Použití této instrukce je různé, může se například použít pro realizaci příkazu continue v programovacím jazyku C.

Podobná instrukce taktéž s jedním zdrojovým registrem se jmenuje CINV:

CINV Wd, Wn, condition
CINV Xd, Xn, condition

Prováděná činnost je následující (tilda znamená negaci bit po bitu):

Wd = condition ? ~Wn : Wn;
Xd = condition ? ~Xn : Xn;

Ve skutečnosti se opět jedná o instrukční alias rozpoznávaný assemblery. V tomto případě lze CINV nahradit instrukcí CSINV s oběma zdrojovými registry totožnými:

CSINV Wd, Wn, Wn, invert(condition)
CSINV Xd, Xn, Xn, invert(condition)

Poslední instrukce, přesněji řečeno (opět) instrukční alias se jmenuje CNEG:

CNEG Wd, Wn, condition
CNEG Xd, Xn, condition

Prováděná činnost:

Wd = condition ? -Wn : Wn;
Xd = condition ? -Xn : Xn;

Tento alias je možné nahradit za CSNEG s totožnými zdrojovými registry a opačně zapsanou podmínkou:

CSNEG Wd, Wn, Wn, invert(condition)
CSNEG Xd, Xn, Xn, invert(condition)

15. Extrakce dat

Poslední skupina instrukcí, o níž se dnes zmíníme, slouží k takzvané extrakci dat. Jak je z tabulky patrné, mají tyto instrukce čtyři operandy, přičemž posledním operandem je konstanta 0..31 pro první instrukci či 0..63 pro instrukci druhou. Tyto dvě instrukce nejprve pomyslně spojí oba vstupní registry Wn:Wm či Xn:Xm a následně z takto vytvořeného dočasného pseudoregistru s dvojnásobnou šířkou získají 32bitové či 64bitové slovo od zadané pozice lsb:

Opět platí, že díky existenci registrů WZR a XZR je možné z těchto instrukcí vytvořit různé aliasy. Taktéž je možné mít oba zdrojové registry totožné – asi nejznámějším aliasem využívajícím dva shodné zdrojové registry je již popsaná instrukce ROR (stačí si představit, jak se z registrového páru Xn:Xn vybírá 63 bitů).

16. Odkazy na Internetu

1. Comparison of ARMv8-A cores
   https://en.wikipedia.org/wi­ki/Comparison_of_ARMv8-A_cores
2. A64 General Instructions
   http://www.keil.com/suppor­t/man/docs/armclang_asm/ar­mclang_asm_pge1427898258836­.htm
3. ARMv8 (AArch64) Instruction Encoding
   http://kitoslab-eng.blogspot.cz/2012/10/armv8-aarch64-instruction-encoding.html
4. Cortex-A32 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a32-processor.php
5. Cortex-A35 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a35-processor.php
6. Cortex-A53 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a53-processor.php
7. Cortex-A57 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a57-processor.php
8. Cortex-A72 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a72-processor.php
9. Cortex-A73 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a73-processor.php
10. Apple A7 (SoC založen na CPU Cyclone)
    https://en.wikipedia.org/wi­ki/Apple_A7
11. System cally pro AArch64 na Linuxu
    https://github.com/torval­ds/linux/blob/master/inclu­de/uapi/asm-generic/unistd.h
12. Architectures/AArch64 (FedoraProject.org)
    https://fedoraproject.org/wi­ki/Architectures/AArch64
13. SIG pro AArch64 (CentOS)
    https://wiki.centos.org/Spe­cialInterestGroup/AltArch/A­Arch64
14. The ARMv8 instruction sets
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
15. A64 Instruction Set
    https://developer.arm.com/pro­ducts/architecture/instruc­tion-sets/a64-instruction-set
16. Switching between the instruction sets
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
17. The A64 instruction set
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
18. Introduction to ARMv8 64-bit Architecture
    https://quequero.org/2014/04/in­troduction-to-arm-architecture/
19. MCU market turns to 32-bits and ARM
    http://www.eetimes.com/do­cument.asp?doc_id=1280803
20. Cortex-M0 Processor (ARM Holdings)
    http://www.arm.com/produc­ts/processors/cortex-m/cortex-m0.php
21. Cortex-M0+ Processor (ARM Holdings)
    http://www.arm.com/produc­ts/processors/cortex-m/cortex-m0plus.php
22. ARM Processors in a Mixed Signal World
    http://www.eeweb.com/blog/arm/arm-processors-in-a-mixed-signal-world
23. ARM Architecture (Wikipedia)
    https://en.wikipedia.org/wi­ki/ARM_architecture
24. DSP for Cortex-M
    https://developer.arm.com/techno­logies/dsp/dsp-for-cortex-m
25. Cortex-M processors in DSP applications? Why not?!
    https://community.arm.com/pro­cessors/b/blog/posts/cortex-m-processors-in-dsp-applications-why-not
26. White Paper – DSP capabilities of Cortex-M4 and Cortex-M7
    https://community.arm.com/pro­cessors/b/blog/posts/white-paper-dsp-capabilities-of-cortex-m4-and-cortex-m7
27. Q (number format)
    https://en.wikipedia.org/wi­ki/Q_%28number_format%29
28. TriCore Architecture & Core
    http://www.infineon.com/cms/en/pro­duct/microcontroller/32-bit-tricore-tm-microcontroller/tricore-tm-architecture-and-core/channel.html?channel=ff80808112ab681d0112­ab6b73d40837
29. TriCoreTM V1.6 Instruction Set: 32-bit Unified Processor Core
    http://www.infineon.com/dgdl/tc_v131_in­structionset_v138.pdf?file­Id=db3a304412b407950112b409b6dd0352
30. TriCore v2.2 C Compiler, Assembler, Linker Reference Manual
    http://tasking.com/suppor­t/tricore/tc_reference_gu­ide_v2.2.pdf
31. Infineon TriCore (Wikipedia)
    https://en.wikipedia.org/wi­ki/Infineon_TriCore
32. C166®S V2 Architecture & Core
    http://www.infineon.com/cms/en/pro­duct/microcontroller/16-bit-c166-microcontroller/c166-s-v2-architecture-and-core/channel.html?channel=db3a304312bef5660112­c3011c7d01ae
33. Comparing four 32-bit soft processor cores
    http://www.eetimes.com/au­thor.asp?section_id=14&doc_id=1286116
34. RISC-V Instruction Set
    http://riscv.org/download­.html#spec_compressed_isa
35. RISC-V Spike (ISA Simulator)
    http://riscv.org/download.html#isa-sim
36. RISC-V (Wikipedia)
    https://en.wikipedia.org/wiki/RISC-V
37. David Patterson (Wikipedia)
    https://en.wikipedia.org/wi­ki/David_Patterson_(compu­ter_scientist)
38. OpenRISC (oficiální stránky projektu)
    http://openrisc.io/
39. OpenRISC architecture
    http://openrisc.io/architecture.html
40. Emulátor OpenRISC CPU v JavaScriptu
    http://s-macke.github.io/jor1k/demos/main.html
41. OpenRISC (Wikipedia)
    https://en.wikipedia.org/wi­ki/OpenRISC
42. OpenRISC – instrukce
    http://sourceware.org/cgen/gen-doc/openrisc-insn.html
43. OpenRISC – slajdy z přednášky o projektu
    https://iis.ee.ethz.ch/~gmichi/a­socd/lecturenotes/Lecture6­.pdf
44. Berkeley RISC
    http://en.wikipedia.org/wi­ki/Berkeley_RISC
45. Great moments in microprocessor history
    http://www.ibm.com/develo­perworks/library/pa-microhist.html
46. Microprogram-Based Processors
    http://research.microsoft.com/en-us/um/people/gbell/Computer_Struc­tures_Principles_and_Exam­ples/csp0167.htm
47. Great Microprocessors of the Past and Present
    http://www.cpushack.com/CPU/cpu1.html
48. A Brief History of Microprogramming
    http://www.cs.clemson.edu/~mar­k/uprog.html
49. What is RISC?
    http://www-cs-faculty.stanford.edu/~ero­berts/courses/soco/projec­ts/2000–01/risc/whatis/
50. RISC vs. CISC
    http://www-cs-faculty.stanford.edu/~ero­berts/courses/soco/projec­ts/2000–01/risc/risccisc/
51. RISC and CISC definitions:
    http://www.cpushack.com/CPU/cpu­AppendA.html
52. FPGA
    https://cs.wikipedia.org/wi­ki/Programovateln%C3%A9_hra­dlov%C3%A9_pole
53. The Evolution of RISC
    http://www.ibm.com/develo­perworks/library/pa-microhist.html#sidebar1