Instrukční sada AArch64 (2.část)

Obsah

1. Instrukční sada AArch64 (2.část)

2. Načtení konstanty do FP registru

3. Přenos operandů mezi registry

4. Konverze mezi různými formáty

5. Převod na celá čísla (zaokrouhlení)

6. Základní aritmetické operace

7. Porovnání operandů

8. SIMD operace

9. Operace s prvky vektorů

10. Aritmetické operace s prvky uloženými ve vektorech

11. Doplnění – problematika načítání konstant

12. Volání služeb jádra (syscall) na procesorech AArch64

13. Příklad programu volajícího službu jádra exit

14. Výsledná podoba binárního souboru s přeloženými instrukcemi

15. Odkazy na Internetu

1. Instrukční sada AArch64 (2.část)

Instrukce používané klasickou celočíselnou aritmeticko-logickou jednotkou 64bitových procesorů s architekturou AArch64 jsme si popsali minule, takže se dnes zaměříme na matematický koprocesor a posléze i na „vektorovou jednotku“. Připomeňme si, že u operací s plovoucí řádovou čárkou je používána samostatná sada pracovních registrů pojmenovaných v0 až v31 s šířkou celých 128 bitů (typ quad), přičemž spodních 64 bitů a také 32 bitů lze využít pro operace s hodnotami typu single/float a double:

Seznam popsaných instrukcí se nám úspěšně rozšiřuje:

Poznámka: většina instrukcí známých ze sady VFP (ARM32) byla přejmenována, ovšem prakticky každá z původních instrukcí má svůj nový ekvivalent. Jen pro upřesnění si vypišme některé původní instrukce VFP:

Aritmetické operace:

Porovnání:

Přesuny dat:

2. Načtení konstanty do FP registru

Pro načtení konstanty typu single/float a double se používá instrukce FMOV. Ovšem vzhledem k tomu, že jak instrukční slovo, tak i konstanta mají dohromady pouhých 32 bitů, je zřejmé, že tímto způsobem není možné načíst libovolné číslo, ale pouze hodnotu odpovídající určitým pravidlům. Reprezentovatelná hodnota odpovídá výrazu ±n÷16×2^r, kde n je celé číslo 16 ≤ n ≤ 31 a r je taktéž celé číslo –3 ≤ r ≤ 4. Tato čísla jsou reprezentována čtyřmi resp. třemi bity, další bit slouží pro uložení znaménka v instrukčním slovu:

Speciálním případem je načtení nuly, které se provede jednoduše – použitím registrů XZR či WZR, které obsahují nulu a konstanta nula (0,0) je ve formátu IEEE 754 taktéž reprezentována samými nulovými bity.

Tento úryvek céčkového kódu:

float  x = 0.0;
double y = 0.0;

se přeloží následovně (jedná se o lokální proměnné ukládané na zásobníkový rámec, tedy relativně vůči SP):

// float x = 0.0
str  wzr, [sp, 28]
 
// double y = 0.0
str  xzr, [sp, 16]

Další instrukce slouží pro načtení operandu z paměti a pro uložení operandů zpět do paměti. Tyto instrukce již známe, pouze došlo k jejich rozšíření i pro použití s FP registry. Operace s jednotlivými bajty se používají u vektorových operací. Samozřejmě nesmíme zapomenout ani na instrukce pro načtení a uložení registrového páru:

Podívejme se opět na použití. Následující fragment céčkového kódu s inicializací čtyř lokálních proměnných:

float  x = 1.0;
float  y = 10.0;
float  z = 100.0;
float  w = 1000.0;

se přeloží takto:

// float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 12]
 
// float  y = 10.0;
fmov    s0, 1.0e+1
str     s0, [sp, 8]
 
// float  z = 100.0;
adrp    x0, .LC0
add     x0, x0, :lo12:.LC0
ldr     s0, [x0]
str     s0, [sp, 4]
 
// float  w = 1000.0;
adrp    x0, .LC1
add     x0, x0, :lo12:.LC1
ldr     s0, [x0]
str     s0, [sp]

První proměnné lze načíst přímo instrukcí FMOV (konstanta je součástí instrukce), další pouze nepřímo z operační paměti.

Konstanty uložené v operační paměti:

.LC0:
        .word   1120403456
.LC1:
        .word   1148846080

3. Přenos operandů mezi registry

Další skupina instrukcí sice taktéž používá mnemotechnickou zkratku FMOV, ovšem neslouží k načtení konstanty, ale k přenosu operandu mezi různými registry. Zajímavé je, že je možné přenášet operandy mezi celočíselnými registry a FP registry; v takovém případě se přenese bitový obraz uloženého čísla a neprovádí se žádné konverze (zaokrouhlení atd.). Poslední dvě instrukce jsou užitečné pro přenos 64 bitů do nebo ze 128 bitového registru Vd:

4. Konverze mezi různými formáty

Pro konverzi hodnot mezi různými formáty (half float, single, double) slouží instrukce nazvaná FCVT (float convert). Některé převody lze provést bez problémů (neztratí se ani přesnost ani rozsah), u dalších převodů buď ztratíme přesnost nebo bude hodnota převedena na ∞ nebo -∞:

Opět se podívejme na příklad použití při konverzi mezi hodnotami lokálních proměnných:

float  x = 1.0;
double y = 1.0;
double z = x;
float  w = y;

// float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 28]
 
// double y = 1.0;
fmov    d0, 1.0e+0
str     d0, [sp, 16]
 
// double z = x;
ldr     s0, [sp, 28]
fcvt    d0, s0
str     d0, [sp, 8]
 
// float  w = y;
ldr     d0, [sp, 16]
fcvt    s0, d0
str     s0, [sp, 4]

5. Převod na celá čísla (zaokrouhlení)

Poměrně rozsáhlá skupina instrukcí slouží pro převod FP hodnot na celá čísla. Podívejme se na tabulku:

Instrukce FCVTNS a FCVTNU zaokrouhlují na nejbližší sudé číslo ty hodnoty, které leží přesně v polovině intervalu (1/2).

Nezapomeneme si samozřejmě ukázat, jak tyto instrukce používá překladač v praxi:

float  x = 1.0;
double y = 2.0;
int    i = x;
int    j = y;

Způsob překladu do assembleru:

// float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 28]
 
// double y = 2.0;
fmov    d0, 2.0e+0
str     d0, [sp, 16]
 
// int    i = x;
ldr     s0, [sp, 28]
fcvtzs  w0, s0
str     w0, [sp, 12]
 
// int    j = y;
ldr     d0, [sp, 16]
fcvtzs  w0, d0
str     w0, [sp, 8]

6. Základní aritmetické operace

Poměrně rozsáhlá je skupina instrukcí určených pro provádění základních aritmetických operací, k nimž navíc přidáváme instrukce pro výpočet absolutní hodnoty, odmocniny, minima, maxima atd.:

Opět se podívejme na příklad, tentokrát s poněkud složitějším výpočtem:

float  x = 1.0;
float  y = 2.0;
float  z = 3.0;
float  w = x*y + y/z + fabs(z);

Tento příklad se (bez optimalizací) přeloží následovně:

// float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 12]
 
// float  y = 2.0;
fmov    s0, 2.0e+0
str     s0, [sp, 8]
 
// float  w = x*y + y/z + fabs(z);
fmov    s0, 3.0e+0
str     s0, [sp, 4]
 
// float  w = x*y + y/z + fabs(z);
ldr     s1, [sp, 12]
ldr     s0, [sp, 8]
fmul    s1, s1, s0 // x*y
ldr     s2, [sp, 8]
ldr     s0, [sp, 4]
fdiv    s0, s2, s0 // y/z
fadd    s1, s1, s0
ldr     s0, [sp, 4]
fabs    s0, s0
fadd    s0, s1, s0

Kombinace aritmetické operace s konverzí výsledku:

float  x = 1.0;
double y = 1.0;
float  z = x+y;

Se může přeložit takto:

// float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 28]
 
// double y = 1.0;
fmov    d0, 1.0e+0
str     d0, [sp, 16]
 
// float  z = x+y;
ldr     s0, [sp, 28]
fcvt    d1, s0
ldr     d0, [sp, 16]
fadd    d0, d1, d0
fcvt    s0, d0
str     s0, [sp, 12]

7. Porovnání operandů

Instrukce, které slouží pro porovnání dvou FP registrů, nastavují příznakové bity N, V, Z a C. To znamená, že tyto instrukce je možné přímo zkombinovat například s podmíněnými skoky:

Podívejme se na jednoduchý příklad, opět využívající lokální proměnné uložené na zásobníkovém rámci:

float  x = 1.0;
float  y = 10.0;
float  z = 20.0;
int i = x == y;
int j = x < y;
int k = x <= y;
int l = x != y;
int m = x > y;

Způsob překladu neoptimalizujícím překladačem:

float  x = 1.0;
fmov    s0, 1.0e+0
str     s0, [sp, 28]
 
// float  y = 10.0;
fmov    s0, 1.0e+1
str     s0, [sp, 24]
 
// float  z = 20.0;
fmov    s0, 2.0e+1
str     s0, [sp, 20]
 
// int i = x == y;
ldr     s1, [sp, 28]
ldr     s0, [sp, 24]
fcmp    s1, s0
cset    w0, eq         // testuje se příznakový bit Z (zero)
uxtb    w0, w0         // rozšíření osmibitové hodnoty na 32 bitů
str     w0, [sp, 16]
 
// int j = x < y;
ldr     s1, [sp, 28]
ldr     s0, [sp, 24]
fcmpe   s1, s0
cset    w0, mi
uxtb    w0, w0         // rozšíření osmibitové hodnoty na 32 bitů
str     w0, [sp, 12]
 
// int k = x <= y;
ldr     s1, [sp, 28]
ldr     s0, [sp, 24]
fcmpe   s1, s0
cset    w0, ls
uxtb    w0, w0         // rozšíření osmibitové hodnoty na 32 bitů
str     w0, [sp, 8]
 
// int l = x != y;
ldr     s1, [sp, 28]
ldr     s0, [sp, 24]
fcmp    s1, s0
cset    w0, ne         // testuje se příznakový bit Z (zero)
uxtb    w0, w0         // rozšíření osmibitové hodnoty na 32 bitů
str     w0, [sp, 4]
 
// int m = x > y;
ldr     s1, [sp, 28]
ldr     s0, [sp, 24]
fcmpe   s1, s0
cset    w0, gt
uxtb    w0, w0         // rozšíření osmibitové hodnoty na 32 bitů

8. SIMD operace

Pro SIMD operace, tj. operace pracující s krátkými vektory, se 128bitové registry Vn rozdělují takto:

U některých instrukcí se uvádí jak zdrojový a cílový vektor, tak i index prvku vektoru. Zápis v assembleru potom může vypadat například takto:

DUP V1.8B, V2.8B, [5]

Poznámka: počet „vektorových“ instrukcí je větší, než počet všech zbývajících instrukcí (včetně instrukcí matematického koprocesoru), takže si dnes budeme moci ukázat pouze malou skupinu vybraných operací. Navíc překladače většinou „vektorové“ instrukce přímo negenerují, pokud samozřejmě ve zdrojových kódech nepoužijeme příslušné intrinsic funkce.

9. Operace s prvky vektorů

Instrukce, s nimiž se seznámíme v této kapitole, slouží k různým manipulacím s prvky vektorů. Příkladem může být první instrukce DUP, která ve své nejjednodušší podobě dokáže zkopírovat vybraný prvek ze zdrojového vektoru do všech prvků vektoru cílového. Navíc může tato instrukce provádět i konverzi dat (například z bajtů na 16bitová celá čísla) atd.:

10. Aritmetické operace s prvky uloženými ve vektorech

Skupina aritmetických instrukcí s prvky uloženými ve vektorech je poměrně rozsáhlá, protože kromě základních instrukcí pro součet, rozdíl, součin a podíl jsou implementovány instrukce pro výpočet rozdílu s následným uložením absolutní hodnoty rozdílu nebo pro součet/rozdíl a vydělení výsledku dvěma. Většina instrukcí pracuje se všemi typy prvků, tj. s vektory zmíněnými v osmé kapitole:

11. Doplnění – problematika načítání konstant

Již několikrát jsme se zmínili o tom, že kvůli konstantní šířce všech instrukcí může být problematické uložení konstanty do některého pracovního registru. Problém je to logický a vlastně shodný pro prakticky všechny „klasické“ RISCové mikroprocesory: šířka pracovních registrů je 32 bitů a současně je šířka instrukcí taktéž 32 bitů, tudíž není možné, aby se v instrukci vedle operačního kódu nacházela i 32 bitová konstanta. Tvůrci dalších RISCových mikroprocesorů se s touto problematikou snažili vypořádat různým způsobem, například zavedli speciální instrukci pro naplnění horních šestnácti bitů registru, zatímco pro naplnění spodních šestnácti bitů bylo možné použít například instrukci ADD s konstantou a nulovým registrem R0 (zhruba takovýmto způsobem je tato problematika řešena na mikroprocesorech MIPS).

U procesorů AArch64 je možné pro načtení konstanty použít kombinace různých instrukcí, typicky MOV a MOVK nebo MOVN a MOVK. V praxi může překladač postupovat následovně:

int a = 100;
int b = 1000;
int c = 10000;
int d = 100000;
int e = 1000000;
int f = 10000000;

Tato inicializace lokálních proměnných se přeloží takto:

// int a = 100;
mov     w0, 100
str     w0, [sp, 28]
 
// int b = 1000;
mov     w0, 1000
str     w0, [sp, 24]
 
// int c = 10000;
mov     w0, 10000
str     w0, [sp, 20]
 
// int d = 100000;
mov     w0, 34464
movk    w0, 0x1, lsl 16
str     w0, [sp, 16]
 
// int e = 1000000;
mov     w0, 16960
movk    w0, 0xf, lsl 16
str     w0, [sp, 12]
 
// int f = 10000000;
mov     w0, 38528
movk    w0, 0x98, lsl 16
str     w0, [sp, 8]

Povšimněte si, že u instrukce MOVK se určuje, do kterého místa cílového registru se konstanta načte (jinými slovy jak se konstanta posune doleva).

12. Volání služeb jádra (syscall) na procesorech AArch64

Volání služeb jádra Linuxu se na procesorech AArch64 hned v několika ohledech odlišuje od původního způsobu volání, které známe z procesorů ARM (dnes tedy ARM32). První změna je pochopitelná – při předávání celočíselných argumentů se používají 64bitové registry x0 až x30 a nikoli 32bitové registry r0 až r14. Druhá změna spočívá v tom, že samotné číslo syscallu se ukládá do registru x8 a nikoli do registru r7. Tuto změnu si můžete poměrně snadno zapamatovat pomocí mnemotechnické pomůcky, protože nejnovější 32bitová jádra mají architekturu ARMv7-A zatímco 64bitová jádra ARMv8-A. Kupodivu došlo i ke změně čísel syscallů, které jsou od původní 32bitové architektury zcela odlišné. Nová čísla syscallů můžete najít například přímo v hlavičkovém souboru Linuxu na adrese https://github.com/torval­ds/linux/blob/master/inclu­de/uapi/asm-generic/unistd.h.

13. Příklad programu volajícího službu jádra exit

Pro zajímavost se podívejme, jak by vypadal program (pravděpodobně dokonce nejjednodušší program vůbec), který po svém spuštění pouze zavolá službu jádra, která program ukončí a předá volajícímu (rodičovskému) procesu návratový kód. Celý program obsahuje pouze tři instrukce, přičemž první instrukce slouží pro naplnění registru obsahujícího číslo služby jádra, druhá instrukce naplní registr s návratovým kódem a třetí instrukce skutečně zavolá jádro (svc znamená supervisor call). V GNU assembleru by varianta určená pro 32bitové procesory ARM vypadala následovně:

# asmsyntax=as
 
# Linux kernel system call
sys_exit=1
 
 
 
.section .data
 
.section .bss
 
.section .text
        .global _start          @ tento symbol ma byt dostupny i z linkeru
 
_start:
        mov   r7,$sys_exit      @ cislo sycallu pro funkci "exit"
        mov   r0,#0             @ exit code = 0
        svc   0                 @ volani Linuxoveho kernelu

Naproti tomu verze pro 64bitové procesory AArch 64 vypadá nepatrně odlišně:

# asmsyntax=as
 
# Linux kernel system call
sys_exit=93
 
 
 
.section .data
 
.section .bss
 
.section .text
        .global _start          // tento symbol ma byt dostupny i z linkeru
 
_start:
        mov  x8, #sys_exit      // cislo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volani Linuxoveho kernelu

Můžeme vidět, že změny se týkají použitých registrů a čísla syscallu. Po překladu však získáme zcela odlišný binární soubor, protože se kódování instrukcí mezi ARM32 a AArch64 zcela změnilo.

Překlad příkladu a jeho slinkování se provede standardním způsobem, tedy s použitím nástrojů as (GNU Assembler – GAS) a ld (GNU Linker):

as aarch64.s -o aarch64.o
ld -s aarch64.o

14. Výsledná podoba binárního souboru s přeloženými instrukcemi

Pro zajímavost se podívejme na obsah vytvořeného spustitelného binárního souboru a.out. Tento obsah získáme dalším nástrojem nazvaným objdump:

objdump -f -d -t -h a.out

a.out:     file format elf64-littleaarch64
architecture: aarch64, flags 0x00000102:
EXEC_P, D_PAGED
start address 0x0000000000400078
 
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         0000000c  0000000000400078  0000000000400078  00000078  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
SYMBOL TABLE:
no symbols
 
 
 
Disassembly of section .text:
 
0000000000400078 <.text>:
  400078:       d2800ba8        mov     x8, #0x5d                       // #93
  40007c:       d2800000        mov     x0, #0x0                        // #0
  400080:       d4000001        svc     #0x0

Povšimněte si, že všechny instrukce mají skutečně konstantní šířku 32 bitů. Navíc je zajímavé, že obě instrukce mov pracují se skutečnými konstantami uloženými přímo v instrukčním slovu (což je ovšem možné jen pro určité konstanty, typicky pro malá kladná i záporná čísla).

15. Odkazy na Internetu

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