Specifické vlastnosti procesorů AArch64: aritmetické operace

Obsah

1. Aritmetické operace s celočíselnými typy i s hodnotami s plovoucí řádovou čárkou

2. Specifické vlastnosti aritmeticko-logické jednotky

3. Hodnoty typu single a double

4. Formát plovoucí řádové binární tečky a norma IEEE 754

5. Operace s hodnotami typu single a double

6. Základní operace s FP hodnotami – načtení konstanty do FP registru

7. Praktický příklad – načtení konstant do registrů D1 a S1

8. Nepodporované konstanty aneb (logické) omezení možností RISCových instrukcí

9. Vynulování registrů Dx a Sx

10. Nepřímé načtení konstant s libovolnou hodnotou do registrů Dx a Sx

11. Přenos operandů mezi registry

12. Ukázka přenosu mezi celočíselným a FP registrem

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

14. Převod FP hodnot na celá čísla (zaokrouhlení)

15. Základní aritmetické operace s hodnotami s plovoucí řádovou čárkou

16. Porovnání operandů s hodnotami s plovoucí řádovou čárkou

17. SIMD operace

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

19. Předchozí články o architektuře AArch64

20. Odkazy na Internetu

1. Aritmetické operace s celočíselnými typy i s hodnotami s plovoucí řádovou čárkou

Nová instrukční sada mikroprocesorů s architekturou AArch64 obsahuje instrukce, které je možné rozdělit do několika oblastí podle toho, jaká jednotka implementovaná uvnitř mikroprocesoru tyto instrukce skutečně spouští. Podívejme se na následující tabulku:

Ve čtvrté části miniseriálu o specifických vlastnostech mikroprocesorů s architekturou AArch64 se budeme zabývat převážně instrukcemi určenými pro provádění aritmetických operací. Tyto instrukce se jak z historických tak i technických důvodů rozdělují na instrukce určené pro celočíselné datové typy (bajt, 16bitové slovo, 32bitové slovo, 64bitové slovo) a na instrukce, které provádějí operace s hodnotami s plovoucí řádovou čárkou (tedy ponejvíce s hodnotami single a double, i když se v této oblasti nově objevil například formát blfoat). Další dělení je možné podle toho, zda instrukce prování operaci s jedinou dvojicí operandů, nebo s dvojicí vektorů (ovšem sada registrů zůstává v tomto případě pořád stejná – konkrétně se jedná o registry V0 až V31,).

2. Specifické vlastnosti aritmeticko-logické jednotky

Kromě toho, že aritmeticko-logická jednotka byla (v porovnání s původní architekturou ARM neboli dnes A32 a T32) rozšířena pro zpracování 64bitových operandů u prakticky všech instrukcí, došlo k jejímu doplnění o vylepšenou násobičku a děličku. Násobička může kromě běžných operací pro násobení provádět i operace typu MAC (Multiply Accumulate), které typicky najdeme u DSP. U AArchu64 je zde ovšem jedna podstatná změna – namísto akumulátoru se 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:

V navazujících kapitolách se zaměříme na registry a instrukce určené pro zpracování numerických hodnot s plovoucí řádovou čárkou.

3. Hodnoty typu single a double

Uložení racionálních čísel ve formátu plovoucí řádové tečky (někdy se taktéž setkáme s označením „FP formát“) se od celočíselného formátu nebo formátu s pevnou řádovou tečkou (v ČR spíše řádovou čárkou) odlišuje především v tom, že si každá numerická hodnota sama v sobě nese aktuální polohu řádové tečky (zatímco v případě, že je tečka/čárka pevně nastavena, je tato informace součástí programu a nikoli hodnoty). Z tohoto důvodu je kromě bitů, které musí být rezervovány pro uložení významných číslic numerické hodnoty, nutné pro každou numerickou hodnotu rezervovat i další bity, v nichž je určena mocnina o nějakém základu (typicky 2, 8, 10 či 16), kterou musí být významné číslice vynásobeny resp. vyděleny. První část čísla uloženého v FP formátu se nazývá mantisa, druhá část exponent (navíc se ještě přidává informace o znaménku). Obecný formát uložení a způsob získání původního čísla je následující:

x_FP=b^e×m

přičemž význam jednotlivých symbolů je následující:

1. x_FX značí reprezentovanou numerickou hodnotu z podmnožiny reálných čísel
2. b je báze, někdy také nazývaná radix
3. e je hodnota exponentu (může být i záporná)
4. m je mantisa, která může být i záporná

Konkrétní formát numerických hodnot reprezentovaných v systému plovoucí řádové tečky závisí především na volbě báze (radixu) a také na počtu bitů rezervovaných pro uložení mantisy a exponentu. V minulosti existovalo značné množství různých formátů plovoucí řádové tečky (vzpomíná si někdo například na Turbo Pascal s jeho šestibajtovým datovým typem real?), v relativně nedávné minulosti se však ustálilo použití formátů specifikovaných v normě IEEE 754 (ta sama je ovšem postupně rozšiřována). Ovšem, jak uvidíme dále, se ukazuje, že původní formáty definované v IEEE 754 nedostačují všem požadavkům, a to na obou stranách spektra (někdo požaduje vyšší přesnost/rozsah, jiný zase rychlost výpočtů a malé paměťové nároky). Proto došlo k rozšíření této normy o nové formáty a nezávisle na tom i na vývoji formátu bfloat16. Nicméně nás dnes budou v souvislosti s procesory AArch64 zajímat především formáty s jednoduchou a dvojitou přesností, neboli single (float) a double.

4. Formát plovoucí řádové binární tečky a norma IEEE 754

V oblasti FP formátů se dnes nejčastěji setkáme s výše zmíněnou normou IEEE 754, popř. jejími rozšířenými variantami. Norma IEEE 754 je velmi užitečná v tom, že specifikuje nejenom vlastní formát uložení numerických hodnot v systému plovoucí řádové tečky, ale (a to je celkem neznámá skutečnost) i pravidla implementace operací s těmito hodnotami, včetně konverzí. Konkrétně je v této normě popsáno:

1. Základní (basic) a rozšířený (extended) formát uložení numerických hodnot.
2. Způsob provádění základních matematických operací:
   • součet
   • rozdíl
   • součin
   • podíl
   • zbytek po dělení
   • druhá odmocnina
   • porovnání
3. Režimy zaokrouhlování.
4. Způsob práce s takzvanými denormalizovanými hodnotami.
5. Pravidla konverze mezi celočíselnými formáty (integer bez a se znaménkem) a formáty s plovoucí řádovou čárkou.
6. Způsob konverze mezi různými formáty s plovoucí řádovou čárkou (single → double atd.).
7. Způsob konverze základního formátu s plovoucí řádovou čárkou na řetězec číslic (včetně nekonečen a nečíselných hodnot).
8. Práce s hodnotami NaN (not a number) a výjimkami, které mohou při výpočtech za určitých předpokladů vzniknout (NaN totiž ve skutečnosti jsou čísla :-).

Obrázek 1: První čip, který používal formát definovaný v IEEE 754 – Intel 8087.
Zdroj: Wikipedia, Autor: Dirk Oppelt

V normě (přesněji řečeno v její rozšířené variantě IEEE 754–2008, resp. její poslední úpravě IEEE 754–2019) nalezneme mj. i tyto FP formáty:

Obrázek 2: Mikroprocesory Pentium i všechny další čipy řady 80×86 již implicitně obsahují plnohodnotný FPU. Zlé jazyky tvrdí, že u první řady Pentií byl FPU tak rychlý jen proto, že výsledky pouze odhadoval :-)

Nás však budou v dalším textu zajímat především formáty single a double.

Typ single (nebo float, popř. float32) vypadá takto:

Exponent je přitom posunutý o hodnotu bias, která je nastavena na 127, protože je použit výše uvedený vztah:

bias=2^eb-1-1

a po dosazení eb=8 (bitů) dostaneme:

bias=2^8–1-1=2⁷-1=128–1=127

Vzorec pro vyjádření reálné hodnoty vypadá následovně:

X_single=(-1)^s × 2^exp-127 × m

Rozsah hodnot, které je možné reprezentovat ve formátu jednoduché přesnosti v normalizovaném tvaru je –3,4×10³⁸ až 3,4×10³⁸. Nejnižší reprezentovatelná (normalizovaná) hodnota je rovna 1,17549×10^-38, denormalizovaná pak 1,40129×10^-45. Jak jsme k těmto hodnotám došli? Zkuste se podívat na následující vztahy:

Formát s dvojitou přesností (double), který je definovaný taktéž normou IEEE 754, se v mnoha ohledech podobá formátu s jednoduchou přesností (single), pouze se zdvojnásobil celkový počet bitů, ve kterých je hodnota uložena, tj. místo 32 bitů se používá plných 64 bitů:

Exponent je v tomto případě posunutý o hodnotu bias=2047 a vzorec pro výpočet reálné hodnoty vypadá takto:

X_double=(-1)^s × 2^exp-2047 × m

Přičemž hodnotu mantisy je možné pro normalizované hodnoty získat pomocí vztahu:

m=1+m₅₁^-1+m₅₀^-2+m₄₉^-3+…+m₀^-52

(m_x představuje x-tý bit mantisy)

Rozsah hodnot ukládaných ve dvojité přesnosti je –1,7×10³⁰⁸..1,7×10³⁰⁸, nejmenší možná nenulová hodnota je rovna 2,2×10^-308.

V novější normě IEEE 754–2008 je specifikován nepovinný formát nazvaný binary128, který se ovšem běžně označuje quadruple precision či jen quad precision. Tento formát je založen na slovech širokých 128 bitů (16 bajtů), která jsou rozdělena takto:

Exponent je v tomto případě posunutý o hodnotu bias=16383. Dekadická přesnost u tohoto formátu dosahuje 34 cifer!

Jen krátce se zmiňme o poslední variantě FP formátu, který se nazývá binary256 či méně formálně octuple precision. Tento formát využívá slova o šířce plných 256 bitů (32 bajtů) s následujícím rozdělením:

Exponent je v tomto případě posunutý o hodnotu bias=262143. Dekadická přesnost u tohoto formátu dosahuje 71 cifer, nejmenší (nenormalizovaná) reprezentovatelná hodnota rozdílná od nuly je přibližně 10⁻⁷⁸⁹⁸⁴, maximální hodnota pak 1.611 ×10⁷⁸⁹¹³ (těžko říct, zda je takový rozsah vůbec reálně využitelný).

5. Operace s hodnotami typu single a double

Matematický koprocesor je sice u architektury AArch64 volitelný (u desktopových procesorů ho najdete vždy), ale oproti 32bitovým ARMům došlo k určitému zjednodušení – už neexistuje rozdělení ABI na soft floating point a hard floating point, protože pro předávání hodnot typu single/float a double jsou vždy použity FP registry popsané v navazující kapitole. Z technologického hlediska sice není soft floating point špatné řešení, ale prakticky způsobovalo (a dodnes způsobuje) množství problémů při distribuci knihoven i aplikací.

Samostatná sada pracovních registrů je používána při operacích s typy single/float a double (tedy s operandy reprezentovanými v systému plovoucí řádové čárky), u SIMD operací a taktéž kryptografickým modulem:

Pro SIMD operace, tj. operace pracující s vektory, se výše uvedené registry Vn rozdělují následujícím způsobem:

Aritmetické operace:

Porovnání:

Přesuny dat:

6. Základní operace s FP hodnotami – načtení konstanty do FP registru

Pro načtení konstanty typu single/float a double do jednoho z pracovních registrů Sx či Dx se používá instrukce nazvaná FMOV. Ovšem vzhledem k tomu, že jak instrukční slovo, tak i konstanta mají dohromady pouhých 32 bitů (jako všechny ostatní RISCové instrukce), 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 (k tomuto omezení se ještě vrátíme):

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 (což je jedna z mnoha vychytávek IEEE 754).

Následující ú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 jednoduchý příklad využití těchto instrukcí v praxi. 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

7. Praktický příklad – načtení konstant do registrů D1 a S1

Použití instrukcí FMOV pro načtení konstanty je snadné v případě, že je konstantu možné uložit přímo do instrukčního slova. Nejdříve načteme konstantu 1.0 do registru D1 (typu double):

# asmsyntax=as
 
# Načtení FP konstanty do registru d1
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        fmov d1, #1.00          // načtení konstanty do registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Obsah výsledného binárního souboru po překladu a slinkování:

$ objdump -d a.out
 
a.out:     file format elf64-littleaarch64
 
 
Disassembly of section .text:
 
0000000000400078 <_start>:
  400078:       1e6e1001        fmov    d1, #1.000000000000000000e+00
  40007c:       d2800ba8        mov     x8, #0x5d                       // #93
  400080:       d2800000        mov     x0, #0x0                        // #0
  400084:       d4000001        svc     #0x0

Podobný příklad, ovšem pro registr S1 a tudíž konstantu typu single:

# asmsyntax=as
 
# Načtení FP konstanty do registru s1
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        fmov s1, #1.00          // načtení konstanty do registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Obsah výsledného binárního souboru po překladu a slinkování je nyní poněkud odlišný:

$ objdump -d a.out
 
a.out:     file format elf64-littleaarch64
 
 
Disassembly of section .text:
 
0000000000400078 <_start>:
  400078:       1e2e1001        fmov    s1, #1.000000000000000000e+00
  40007c:       d2800ba8        mov     x8, #0x5d                       // #93
  400080:       d2800000        mov     x0, #0x0                        // #0
  400084:       d4000001        svc     #0x0

8. Nepodporované konstanty aneb (logické) omezení možností RISCových instrukcí

Některé konstanty (přesněji řečeno jejich naprostou většinu) není možné uložit do instrukčního slova instrukce FMOV, o čemž se můžeme velmi snadno přesvědčit:

.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        fmov s1, #0.00          // načtení konstanty do registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Při pokusu o překlad tohoto kódu nastane chyba:

fmov3.s: Assembler messages:
fmov3.s:33: Error: invalid floating-point constant at operand 2 -- `fmov s1,#0.00'

9. Vynulování registrů Dx a Sx

V šesté kapitole jsme si řekli, že vynulování registrů Dx či Sx dosáhneme přesunem nulové hodnoty z registru XZR resp. WZR. Nejdříve si ukažme vynulování registru S1, tedy typu single:

# asmsyntax=as
 
# Načtení FP konstanty do registru s1
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        fmov s1, wzr            // načtení konstanty do registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Způsob překladu:

$ objdump -d a.out
 
a.out:     file format elf64-littleaarch64
 
 
Disassembly of section .text:
 
0000000000400078 <_start>:
  400078:       1e2703e1        fmov    s1, wzr
  40007c:       d2800ba8        mov     x8, #0x5d                       // #93
  400080:       d2800000        mov     x0, #0x0                        // #0
  400084:       d4000001        svc     #0x0

A vynulování registru D1, tedy typu double:

# asmsyntax=as
 
# Načtení FP konstanty do registru d1
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        fmov d1, xzr            // načtení konstanty do registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

A způsob překladu do objektového kódu:

$ objdump -d a.out
 
a.out:     file format elf64-littleaarch64
 
 
Disassembly of section .text:
 
0000000000400078 <_start>:
  400078:       9e6703e1        fmov    d1, xzr
  40007c:       d2800ba8        mov     x8, #0x5d                       // #93
  400080:       d2800000        mov     x0, #0x0                        // #0
  400084:       d4000001        svc     #0x0

10. Nepřímé načtení konstant s libovolnou hodnotou do registrů Dx a Sx

Konstanty, které nelze zakódovat do instrukčního slova instrukce FMOV, se většinou celé (32 bitů či 64 bitů) ukládají do paměti a načítají instrukcí LDR. Jediný problém spočívá v tom, že assembler (resp. GNU Assembler) nedokáže rozpoznat konstanty typu single či double, takže je nutné hodnotu nejdříve získat konverzí do decimálního či hexadecimálního tvaru. K tomuto účelu lze použít aplikaci dostupnou na adrese https://baseconvert.com/ieee-754-floating-point.

Konkrétně může načtení 64bitové konstanty do registru D1 vypadat takto:

ldr  d1, =0x3FF0000000000000 // načtení konstanty do registru

Následuje příklad použití:

# asmsyntax=as
 
# Načtení FP konstanty do registru d1
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        ldr  d1, =0x3FF0000000000000 // načtení konstanty do registru
 
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Způsob překladu do strojového kódu je v tomto případě velmi zajímavý, protože samotná konstanta je uložena za samotným kódem a je načtena s využitím „krátké“ adresy uložené přímo v instrukčním slovu instrukce ldr:

$ objdump -d a.out
 
a.out:     file format elf64-littleaarch64
 
 
Disassembly of section .text:
 
0000000000400078 <_start>:
  400078:       5c000081        ldr     d1, 400088 <_start+0x10>
  40007c:       d2800ba8        mov     x8, #0x5d                       // #93
  400080:       d2800000        mov     x0, #0x0                        // #0
  400084:       d4000001        svc     #0x0
  400088:       4048f5c3        .word   0x4048f5c3
  40008c:       00000000        .word   0x00000000

11. Přenos operandů mezi registry

Další skupina instrukcí mikroprocesorů s architekturou AArch64 sice taktéž používá mnemotechnickou zkratku FMOV, ovšem neslouží k načtení konstanty, ale k přenosu operandu (tedy konkrétní hodnoty) 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 přesný 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 naopak ze 128 bitového registru Vd:

12. Ukázka přenosu mezi celočíselným a FP registrem

V dalším demonstračním příkladu je ukázán způsob přenosu dat mezi registry X1, D1 a X2 s využitím instrukce FMOV:

# asmsyntax=as
 
# Přesuny mezi celočíselnými a FP registry
# v assembleru GNU AS pro architekturu AArch64.
#
# Autor: Pavel Tišnovský
 
 
 
# Linux kernel system call table
sys_exit=93
 
# List of syscalls for AArch64:
# https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
 
 
 
#-----------------------------------------------------------------------------
.section .data
 
 
 
#-----------------------------------------------------------------------------
.section .bss
 
 
 
#-----------------------------------------------------------------------------
.section .text
        .global _start          // tento symbol má být dostupný i z linkeru
 
_start:
        mov  x1, #0x1234        // načtení celočíselné konstanty
        fmov d1, x1             // přenos do FP registru
        fmov x2, d1             // zpětný přenos do celočíselného registru
 
        mov  x8, #sys_exit      // číslo sycallu pro funkci "exit"
        mov  x0, #0             // exit code = 0
        svc  0                  // volání Linuxového kernelu

Přenosy si můžeme ověřit „naživo“ v GNU Debuggeru. Pro tento účel se provede překlad s využitím přepínače -g:

$ as -g -o a.o src.s
$ ld -g -o a.out a.o

Výsledný binární soubor načteme do GNU Debuggeru:

$ gdb a.out

Nastavíme breakpoint na začátek kódu, tedy na návěští _start:

(gdb) b _start

Následně program spustíme:

(gdb) r

Program se zastaví na první instrukci (díky breakpointu), takže si zobrazíme obsah pracovních registrů:

(gdb) info registers

x0             0x0                 0
x1             0x0                 0
x2             0x0                 0
...
...
...

Další instrukce se provede příkazem n (next). Opět si zobrazíme obsah registrů:

(gdb) info registers

x0             0x0                 0
x1             0x1234              4660
x2             0x0                 0
...
...
...

Další instrukce provádí přenos do D1, takže si musíme zobrazit obsah registrů matematického koprocesoru:

(gdb) info float

d0             {f = 0x0, u = 0x0, s = 0x0} {f = 0, u = 0, s = 0}
d1             {f = 0x0, u = 0x1234, s = 0x1234} {f = 2.3023459096202089e-320, u = 4660, s = 4660}
d2             {f = 0x0, u = 0x0, s = 0x0} {f = 0, u = 0, s = 0}
...
...
...

A poslední instrukce přenese stejná data do celočíselného registru X2:

(gdb) info registers

x0             0x0                 0
x1             0x1234              4660
x2             0x1234              4660
x3             0x0                 0
...
...
...

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

Pro konverzi hodnot mezi různými numerickými formáty s plovoucí řádovou čárkou (half float, single, double) slouží instrukce nazvaná FCVT (neboli float convert). Některé převody lze provést bez problémů (neztratí se tedy ani přesnost ani rozsah), u dalších převodů buď ztratíme přesnost nebo bude hodnota převedena na ∞ nebo -∞ (což je ovšem očekávané chování):

Opět se podívejme na prozatím velmi jednoduchý 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;

Překlad tohoto úryvku kódu do assembleru:

// 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]

14. Převod FP hodnot na celá čísla (zaokrouhlení)

Poměrně rozsáhlá skupina strojových instrukcí slouží pro převod FP hodnot (tedy numerických hodnot reprezentovaných v systému plovoucí řádové čárky) na celá čísla. Podívejme se na tabulku se seznamem těchto instrukcí:

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 tohoto programového bloku do assembleru vypadá následovně:

// 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]

15. Základní aritmetické operace s hodnotami s plovoucí řádovou čárkou

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 nepatrně 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]

16. Porovnání operandů s hodnotami s plovoucí řádovou čárkou

Instrukce, které slouží pro porovnání obsahu dvou FP registrů, nastavují příznakové bity N, V, Z a C (prakticky stejným způsobem, jako instrukce celočíselné). To znamená, že tyto instrukce je možné přímo zkombinovat například s podmíněnými skoky:

Podívejme se nyní na jednoduchý demonstrační 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ů

17. SIMD operace

Zbývá nám si popsat „maličkost“ a to konkrétně SIMD operace, které umožňují provádět výpočty nad celými vektory hodnot. Ve skutečnosti je počet „vektorových“ instrukcí větší, než počet všech zbývajících instrukcí (včetně instrukcí matematického koprocesoru), takže si na jejich popis vyhradíme celý článek.

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

Všechny minule i dnes popisované demonstrační příklady byly společně s podpůrným souborem Makefile určeným pro jejich překlad či naopak pro disassembling, uloženy do GIT repositáře dostupného na adrese https://github.com/tisnik/pre­sentations/. Všechny příklady jsou určeny pro standardní GNU Assembler a používají výchozí syntaxi procesorů AArch64. Následuje tabulka s odkazy na zdrojové kódy příkladů i na již zmíněné podpůrné skripty:

19. Předchozí články o architektuře AArch64

S architekturou AArch64 jsme se již na stránkách Roota setkali, a to konkrétně v následujících článcích, z nichž v dnešním článku vycházíme:

1. 64bitové mikroprocesory s architekturou AArch64
   https://www.root.cz/clanky/64bitove-mikroprocesory-s-architekturou-aarch64/
2. Instrukční sada AArch64
   https://www.root.cz/clanky/instrukcni-sada-aarch64/
3. Instrukční sada AArch64 (2.část)
   https://www.root.cz/clanky/instrukcni-sada-aarch64–2-cast/
4. Tvorba a ladění programů v assembleru mikroprocesorů AArch64
   https://www.root.cz/clanky/tvorba-a-ladeni-programu-v-assembleru-mikroprocesoru-aarch64/
5. Instrukční sada AArch64: technologie NEON
   https://www.root.cz/clanky/instrukcni-sada-aarch64-technologie-neon/
6. Specifické vlastnosti procesorů AArch64: základní instrukce
   https://www.root.cz/clanky/specificke-vlastnosti-procesoru-aarch64-zakladni-instrukce/
7. Specifické vlastnosti procesorů AArch64: podmíněné a nepodmíněné skoky, adresování dat
   https://www.root.cz/clanky/specificke-vlastnosti-procesoru-aarch64-podminene-a-nepodminene-skoky-adresovani-dat/
8. Specifické vlastnosti procesorů AArch64: přenos bloků dat a instrukce s podmínkou
   https://www.root.cz/clanky/specificke-vlastnosti-procesoru-aarch64-prenos-bloku-dat-a-instrukce-s-podminkou/

20. Odkazy na Internetu

1. Arm Architecture Reference Manual for A-profile architecture
   https://developer.arm.com/do­cumentation/ddi0487/latest
2. The GNU Assembler – macros
   http://tigcc.ticalc.org/doc/gnu­asm.html#SEC109
3. GNU Binutils
   https://sourceware.org/binutils/
4. Documentation for binutils 2.38
   https://sourceware.org/binutils/docs-2.38/
5. AArch64 Instruction Set Architecture
   https://developer.arm.com/ar­chitectures/learn-the-architecture/aarch64-instruction-set-architecture/instruction-sets-in-the-arm-architecture
6. Arm Armv8-A A32/T32 Instruction Set Architecture
   https://developer.arm.com/do­cumentation/ddi0597/2021–12/?lang=en
7. Comparison of ARMv8-A cores
   https://en.wikipedia.org/wi­ki/Comparison_of_ARMv8-A_cores
8. Cortex-A32 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a32-processor.php
9. Cortex-A35 Processor
   https://www.arm.com/produc­ts/processors/cortex-a/cortex-a35-processor.php
10. Cortex-A53 Processor
    https://www.arm.com/produc­ts/processors/cortex-a/cortex-a53-processor.php
11. Cortex-A57 Processor
    https://www.arm.com/produc­ts/processors/cortex-a/cortex-a57-processor.php
12. Cortex-A72 Processor
    https://www.arm.com/produc­ts/processors/cortex-a/cortex-a72-processor.php
13. Cortex-A73 Processor
    https://www.arm.com/produc­ts/processors/cortex-a/cortex-a73-processor.php
14. Apple A7 (SoC založen na CPU Cyclone)
    https://en.wikipedia.org/wi­ki/Apple_A7
15. System cally pro AArch64 na Linuxu
    https://github.com/torval­ds/linux/blob/master/inclu­de/uapi/asm-generic/unistd.h
16. Architectures/AArch64 (FedoraProject.org)
    https://fedoraproject.org/wi­ki/Architectures/AArch64
17. SIG pro AArch64 (CentOS)
    https://wiki.centos.org/Spe­cialInterestGroup/AltArch/A­Arch64
18. The ARMv8 instruction sets
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
19. A64 Instruction Set
    https://developer.arm.com/pro­ducts/architecture/instruc­tion-sets/a64-instruction-set
20. Switching between the instruction sets
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
21. The A64 instruction set
    http://infocenter.arm.com/hel­p/index.jsp?topic=/com.ar­m.doc.den0024a/ch05s01.html
22. Introduction to ARMv8 64-bit Architecture
    https://quequero.org/2014/04/in­troduction-to-arm-architecture/
23. MCU market turns to 32-bits and ARM
    http://www.eetimes.com/do­cument.asp?doc_id=1280803
24. Cortex-M0 Processor (ARM Holdings)
    http://www.arm.com/produc­ts/processors/cortex-m/cortex-m0.php
25. Cortex-M0+ Processor (ARM Holdings)
    http://www.arm.com/produc­ts/processors/cortex-m/cortex-m0plus.php
26. ARM Processors in a Mixed Signal World
    http://www.eeweb.com/blog/arm/arm-processors-in-a-mixed-signal-world
27. ARM Architecture (Wikipedia)
    https://en.wikipedia.org/wi­ki/ARM_architecture
28. DSP for Cortex-M
    https://developer.arm.com/techno­logies/dsp/dsp-for-cortex-m
29. 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
30. 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
31. Q (number format)
    https://en.wikipedia.org/wi­ki/Q_%28number_format%29
32. 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
33. TriCoreTM V1.6 Instruction Set: 32-bit Unified Processor Core
    http://www.infineon.com/dgdl/tc_v131_in­structionset_v138.pdf?file­Id=db3a304412b407950112b409b6dd0352
34. TriCore v2.2 C Compiler, Assembler, Linker Reference Manual
    http://tasking.com/suppor­t/tricore/tc_reference_gu­ide_v2.2.pdf
35. Infineon TriCore (Wikipedia)
    https://en.wikipedia.org/wi­ki/Infineon_TriCore
36. 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
37. Comparing four 32-bit soft processor cores
    http://www.eetimes.com/au­thor.asp?section_id=14&doc_id=1286116
38. RISC-V Instruction Set
    http://riscv.org/download­.html#spec_compressed_isa
39. RISC-V Spike (ISA Simulator)
    http://riscv.org/download.html#isa-sim
40. RISC-V (Wikipedia)
    https://en.wikipedia.org/wiki/RISC-V
41. David Patterson (Wikipedia)
    https://en.wikipedia.org/wi­ki/David_Patterson_(compu­ter_scientist)
42. OpenRISC (oficiální stránky projektu)
    http://openrisc.io/
43. OpenRISC architecture
    http://openrisc.io/architecture.html
44. Emulátor OpenRISC CPU v JavaScriptu
    http://s-macke.github.io/jor1k/demos/main.html
45. OpenRISC (Wikipedia)
    https://en.wikipedia.org/wi­ki/OpenRISC
46. OpenRISC – instrukce
    http://sourceware.org/cgen/gen-doc/openrisc-insn.html
47. OpenRISC – slajdy z přednášky o projektu
    https://iis.ee.ethz.ch/~gmichi/a­socd/lecturenotes/Lecture6­.pdf
48. Berkeley RISC
    http://en.wikipedia.org/wi­ki/Berkeley_RISC
49. Great moments in microprocessor history
    http://www.ibm.com/develo­perworks/library/pa-microhist.html
50. Microprogram-Based Processors
    http://research.microsoft.com/en-us/um/people/gbell/Computer_Struc­tures_Principles_and_Exam­ples/csp0167.htm
51. Great Microprocessors of the Past and Present
    http://www.cpushack.com/CPU/cpu1.html
52. A Brief History of Microprogramming
    http://www.cs.clemson.edu/~mar­k/uprog.html
53. What is RISC?
    http://www-cs-faculty.stanford.edu/~ero­berts/courses/soco/projec­ts/2000–01/risc/whatis/
54. RISC vs. CISC
    http://www-cs-faculty.stanford.edu/~ero­berts/courses/soco/projec­ts/2000–01/risc/risccisc/
55. RISC and CISC definitions:
    http://www.cpushack.com/CPU/cpu­AppendA.html
56. FPGA
    https://cs.wikipedia.org/wi­ki/Programovateln%C3%A9_hra­dlov%C3%A9_pole
57. The Evolution of RISC
    http://www.ibm.com/develo­perworks/library/pa-microhist.html#sidebar1
58. disasm.pro
    https://disasm.pro/
59. Exploring AArch64 assembler – Chapter 5
    https://thinkingeek.com/2016/11/13/ex­ploring-aarch64-assembler-chapter-5/
60. Brain Floating Point – nový formát uložení čísel pro strojové učení a chytrá čidla
    https://www.root.cz/clanky/brain-floating-point-ndash-novy-format-ulozeni-cisel-pro-strojove-uceni-a-chytra-cidla/
61. Why Intel is betting on BFLOAT16 to be a game changer for deep learning training? Hint: Range trumps Precision
    https://hub.packtpub.com/why-intel-is-betting-on-bfloat16-to-be-a-game-changer-for-deep-learning-training-hint-range-trumps-precision/
62. half-rs (pro Rust)
    https://github.com/starkat99/half-rs
63. float16 (pro Go)
    https://github.com/x448/float16
64. bfloat16 – Hardware Numerics Definition
    https://software.intel.com/en-us/download/bfloat16-hardware-numerics-definition
65. Intel Prepares To Graft Google’s Bfloat16 Onto Processors
    https://www.nextplatform.com/2019/07/15/in­tel-prepares-to-graft-googles-bfloat16-onto-processors/
66. Norma IEEE 754 a příbuzní: formáty plovoucí řádové tečky
    https://www.root.cz/clanky/norma-ieee-754-a-pribuzni-formaty-plovouci-radove-tecky/
67. IEEE-754 Floating-Point Conversion
    http://babbage.cs.qc.cuny.edu/IEEE-754.old/32bit.html
68. Small Float Formats
    https://www.khronos.org/o­pengl/wiki/Small_Float_For­mats
69. Binary-coded decimal
    https://en.wikipedia.org/wiki/Binary-coded_decimal
70. Chen–Ho encoding
    https://en.wikipedia.org/wi­ki/Chen%E2%80%93Ho_encoding
71. Densely packed decimal
    https://en.wikipedia.org/wi­ki/Densely_packed_decimal
72. A Summary of Chen-Ho Decimal Data encoding
    http://speleotrove.com/decimal/chen-ho.html
73. Art of Assembly language programming: The 80×87 Floating Point Coprocessors
    https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–3.html
74. Art of Assembly language programming: The FPU Instruction Set
    https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–4.html
75. INTEL 80387 PROGRAMMER'S REFERENCE MANUAL
    http://www.ragestorm.net/dow­nloads/387intel.txt
76. Floating-Point Formats
    http://www.quadibloc.com/com­p/cp0201.htm
77. Floating Point Numbers
    https://floating-point-gui.de/formats/fp/
78. Float exposed
    https://float.exposed/0×40490000
79. Float Toy
    http://evanw.github.io/float-toy/
80. IEEE-754 visualization
    https://bartaz.github.io/ieee754-visualization/
81. IEEE-754 Floating Point Converter
    https://www.h-schmidt.net/FloatConverter/I­EEE754.html
82. IEEE 754 Calculator
    http://weitz.de/ieee/
83. IEEE-754 Float Calculator
    https://mason.cc/float/