Gleitkommaoperationen

Aus C und Assembler mit Raspberry

In diesem Kapitel werden wir uns mit Gleitkommaoperationen im ARM64-Assembler beschäftigen. Die Schwerpunkte liegen auf den FPU-Registern (Floating Point Unit), einem Überblick über die Register und deren Verwendung in Funktionen. Ebenso werden wichtige Hinweise zur Verwendung der Register für Gleitkommaoperationen gegeben.

FPU-Register: Überblick

Unter ARM64 haben wir eine dedizierte Einheit für Gleitkommaoperationen, die sogenannte FPU (Floating Point Unit). Diese Einheit verwendet spezifische Register, um Gleitkommaoperationen auszuführen.

Registerüberblick

  • h0 - h31: Einfaches-Gleitkomma-Register (16-Bit)
  • s0 - s31: Einzelpräzisions-Gleitkomma-Register (32-Bit)
  • d0 - d31: Doppelpräzisions-Gleitkomma-Register (64-Bit)
  • q0 - q31: Vektorregister (128-Bit) (auch v0 - v31)

Der NEON-Coprozessor verwendet das V-Register. Allerdings kann der Coprozessor auch mit 128-Bit Ganzzahlen umgehen. Dies sind die gleichen Register, werden aber "Q"-Register genannt.

  • Register "d" ist ein Teil des Register "v", das Register "s" ein Teil des Registers "d" usw. Dies ist zu vergleichen wie bei den ARM-Registern "x" und "w".
Bits 127 - 112 111 - 96 95 - 80 79 - 64 63 - 48 47 - 32 31 - 16 15 - 0
V-Register (NEON)
Q-Register (FPU)		 128-Bit
D-Register (FPU) 64-Bit
S-Register (FPU) 32-Bit
H-Register (FPU) 16-Bit

Der NEON-Coprozessor verwendet das V-Register. Allerdings kann der Coprozessor auch mit 128-Bit Ganzzahlen umgehen. Dies sind die gleichen Register, werden aber "Q"-Register genannt.

Diese Register werden für verschiedene Arten von Gleitkommaoperationen und SIMD (Single Instruction, Multiple Data) verwendet. Hier konzentrieren wir uns hauptsächlich auf die Register d0 bis d31 für Doppelpräzisions-Gleitkommaoperationen.

Verwendung der FPU-Register in Funktionen

Um Gleitkommaoperationen in ARM64-Assembler durchzuführen, sind bestimmte Anweisungen und Register zu beachten. Im Folgenden finden Sie grundlegende Beispiele und Best Practices für die Durchführung von Gleitkommaoperationen.

Beispiel: Gleitkommaaddition 

.section .data
    var1: .double 3.14
    var2: .double 1.618

.section .text
.global _start

_start:
    // Lade Gleitkommawerte in d-Register
    ldr x0, =var1
    ldr d0, [x0]
    ldr x1, =var2
    ldr d1, [x1]

    // Führe die Gleitkommaaddition durch
    fadd d2, d0, d1  // d2 = d0 + d1

    // Beispiel: Rückgabe des Ergebnisses mit einem Systemaufruf 
    // (zur Vereinfachung hier nicht gezeigt, da Gleitkomma nicht direkt unterstützt wird)

    // Exit system call
    mov x8, #93       // syscall number for exit
    mov x0, #0        // exit code
    svc 0

Hinweise zur Verwendung von FPU-Registern

  • Laden und Speichern von Gleitkommawerten: Verwendung von Load/Store-Instruktionen wie ldr und str, um Werte in und aus den FPU-Registern zu laden bzw. zu speichern.
  • Arithmetische Operationen: Verwendung von speziellen Instruktionen wie fadd (Addition), fsub (Subtraktion), fmul (Multiplikation) und fdiv (Division) für Gleitkommaarithmetik.
  • Beachtung von Doppelpräzisionsregistern: Verwenden Sie d-Register für doppelpräzise Gleitkommazahlen.
  • Parameterübergabe: Gleitkommaargumente werden in den d0 bis d7 Registern übergeben, ähnlich wie Ganzzahlen in x0 bis x7.

Beispiel: Gleitkommamultiplikation in einer Funktion

Funktionsdefinition in C: 

// float_functions.c
double multiply(double a, double b) {
    return a * b;
}

Aufruf der Funktion aus Assembler: 

.extern multiply

.global _start

_start:
    // Parameter für die Funktion laden
    ldr x0, =var1
    ldr d0, [x0]
    ldr x1, =var2
    ldr d1, [x1]

    // Aufruf der C-Funktion
    bl multiply

    // Das Ergebnis ist in d0
    // Beispiel: Gleitkommaergebnis weiter verarbeiten
    // (hier nicht weiter verwendet)

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Funktionsdefinition im Assembler: 

.global multiply

multiply:
    fmul d0, d0, d1   // Führe die Multiplikation durch: d0 = d0 * d1
    ret               // Rückkehr zur aufrufenden Funktion

Parameterübergabe und Rückgabewert

Wie bereits erwähnt, werden Gleitkommaargumente in den Registern d0 bis d7 übergeben und Rückgabewerte in d0. Hier ein Beispiel, das zeigt, wie Sie eine Gleitkommafuntionsdefinition in Assembler schreiben und von C aus aufrufen.

C-Beispiel: 

// main.c
#include <stdio.h>

extern double asm_multiply(double a, double b);

int main() {
    double result = asm_multiply(3.14, 1.618);
    printf("Ergebnis: %f\n", result);
    return 0;
}

Assemblerfunktion: 

.global asm_multiply

asm_multiply:
    fmul d0, d0, d1   // Führe die Multiplikation durch: d0 = d0 * d1
    ret               // Rückkehr zur aufrufenden Funktion

Kompilierung und Linken: 

gcc -c main.c
as -o float_functions.o float_functions.s
gcc -o myprogram main.o float_functions.o

Regeln zur Verwendung der Register in Funktionen (AAPCS)

Auch hier müssen bestimmte Register auf dem Stack gesichert werden, da die Aufrufende Funktion davon ausgeht, dass diese nicht verloren gehen, wenn sie eine Funktion aufruft.

Davon sind die Register V8-V15 betroffen. Werden diese verwendet, müssen diese auf dem Stack gesichert werden und am ende der Funktion wieder hergestellt werden.

Beispiel: 

stp q8,q9,[sp,#-32]!
str q10, [sp,#16]!
ldr q10,[sp],#16
ldp q8,q9,[sp],#32

Beispiele für die Verwendung

Kopieren (fmov)

.section .data
var1: .double 3.14

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    fmov d1, d0         // Kopiere d0 nach d1

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Addition (fadd)

.section .data
var1: .double 3.14
var2: .double 1.618

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    ldr x1, =var2
    ldr d1, [x1]        // Lade var2 in d1

    fadd d2, d0, d1     // d2 = d0 + d1 (3.14 + 1.618)

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Subtraktion (fsub)

.section .data
var1: .double 3.14
var2: .double 1.618

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    ldr x1, =var2
    ldr d1, [x1]        // Lade var2 in d1

    fsub d2, d0, d1     // d2 = d0 - d1 (3.14 - 1.618)

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Multiplikation (fmul)

.section .data
var1: .double 3.14
var2: .double 1.618

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    ldr x1, =var2
    ldr d1, [x1]        // Lade var2 in d1

    fmul d2, d0, d1     // d2 = d0 * d1 (3.14 * 1.618)

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Division (fdiv)

.section .data
var1: .double 3.14
var2: .double 1.618

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    ldr x1, =var2
    ldr d1, [x1]        // Lade var2 in d1

    fdiv d2, d0, d1     // d2 = d0 / d1 (3.14 / 1.618)

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Konvertierung von Gleitkommazahlen

Ganzzahl zu Gleitkommazahl (scvtf / ucvtf)

.section .data
int_val: .word 10

.section .text
.global _start

_start:
    ldr w0, =int_val
    ldr w1, [w0]        // Lade int_val in w0

    scvtf d0, w1        // Wandle signed integer w1 in double d0 um

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0
Weitere Konvertierungsmöglichkeiten (Zusammengefast)

Un/Signed Convert to Floating Point:

  • SCVTF <Sd>, <Wn>: Konvertiert einen 32-Bit-Ganzzahlwert ('<Wn>' ) in eine 32-Bit-Single-Precision-Floatzahl ('<Sd>' ).
  • SCVTF <Dd>, <Wn>: Konvertiert einen 32-Bit-Ganzzahlwert ('<Wn>' ) in eine 64-Bit-Double-Precision-Floatzahl ('<Dd>' ).
  • SCVTF <Sd>, <Xn>: Konvertiert einen 64-Bit-Ganzzahlwert ('<Xn>' ) in eine 32-Bit-Single-Precision-Floatzahl ('<Sd>' ).
  • SCVTF <Dd>, <Xn>: Konvertiert einen 64-Bit-Ganzzahlwert ('<Xn>' ) in eine 64-Bit-Double-Precision-Floatzahl ('<Dd>' ).


Gleitkommazahl zu Ganzzahl (fcvtzs / fcvtzu)

.section .data
float_val: .double 3.14

.section .text
.global _start

_start:
    ldr x0, =float_val
    ldr d0, [x0]        // Lade float_val in d0

    fcvtzs w1, d0       // Wandle double d0 in signed integer w1 um

    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0
Weitere Befehle zur Konvertirung nach Ganzzahl
  • FCVTxx Instruktionen
FCVTZS (Floating-point Convert to Signed integer, rounding toward Zero):
  • Konvertiert eine Gleitkommazahl in eine vorzeichenbehaftete Ganzzahl mittels Abrundung in Richtung Null (Truncation).
 FCVTZS <Wd>, <Sn>  // Konvertiert eine Single-Precision Gleitkommazahl (<Sn>) in eine 32-Bit Ganzzahl (<Wd>).
 FCVTZS <Xd>, <Sn>  // Konvertiert eine Single-Precision Gleitkommazahl (<Sn>) in eine 64-Bit Ganzzahl (<Xd>).
 FCVTZS <Wd>, <Dn>  // Konvertiert eine Double-Precision Gleitkommazahl (<Dn>) in eine 32-Bit Ganzzahl (<Wd>).
 FCVTZS <Xd>, <Dn>  // Konvertiert eine Double-Precision Gleitkommazahl (<Dn>) in eine 64-Bit Ganzzahl (<Xd>).
 FCVTZS <Vd>.<T>, <Vn>.<T>  // SIMD: Konvertiert Gleitkommazahlen in Ganzzahlen, z.B. <Vd>.4S, <Vn>.4S.
  • Konvertiert eine Gleitkommazahl in eine vorzeichenlose Ganzzahl durch Abrundung in Richtung Null.
 FCVTZU <Wd>, <Sn>  // Konvertiert eine Single-Precision Gleitkommazahl (<Sn>) in eine 32-Bit Unsigned Ganzzahl (<Wd>).
 FCVTZU <Xd>, <Sn>  // Konvertiert eine Single-Precision Gleitkommazahl (<Sn>) in eine 64-Bit Unsigned Ganzzahl (<Xd>).
 FCVTZU <Wd>, <Dn>  // Konvertiert eine Double-Precision Gleitkommazahl (<Dn>) in eine 32-Bit Unsigned Ganzzahl (<Wd>).
 FCVTZU <Xd>, <Dn>  // Konvertiert eine Double-Precision Gleitkommazahl (<Dn>) in eine 64-Bit Unsigned Ganzzahl (<Xd>).
 FCVTZU <Vd>.<T>, <Vn>.<T>  // SIMD: Konvertiert Gleitkommazahlen in Unsigned Ganzzahlen, z.B. <Vd>.4S, <Vn>.4S.
  • Verwendung und Syntax

Die FCVTZS und FCVTZU Instruktionen können sowohl auf skalare Werte als auch auf SIMD-Vektoren angewendet werden. Beispiele für die Nutzung: 

// Skalare Konvertierungen
FCVTZS W0, S1  // Konvertiert die Single-Precision Gleitkommazahl in S1 zu einer 32-Bit Ganzzahl und speichert sie in W0.
FCVTZS X1, D2  // Konvertiert die Double-Precision Gleitkommazahl in D2 zu einer 64-Bit Ganzzahl und speichert sie in X1.

FCVTZU W0, S1  // Konvertiert die Single-Precision Gleitkommazahl in S1 zu einer 32-Bit Unsigned Ganzzahl und speichert sie in W0.
FCVTZU X1, D2  // Konvertiert die Double-Precision Gleitkommazahl in D2 zu einer 64-Bit Unsigned Ganzzahl und speichert sie in X1.


Weitere Konvertierungsbefehle

fcvt d0, s1 // s1 -> d0
fcvt s1, d0 // d0 -> s1
fcvt s1, h2 // h2 -> s1
fcvt h2, s1 // s1 -> h2

Vergleich von Gleitkommazahlen und bedingte Sprungbefehle

Vergleich von Gleitkommazahlen (fcmpe / fcsel)

.section .data
var1: .double 3.14
var2: .double 1.618

.section .text
.global _start

_start:
    ldr x0, =var1
    ldr d0, [x0]        // Lade var1 in d0
    ldr x1, =var2
    ldr d1, [x1]        // Lade var2 in d1

    fcmpe d0, d1        // Vergleiche d0 und d1
    b.gt greater        // Springe zu 'greater', wenn d0 > d1

    // Kleiner oder gleich Fall
 le_or_eq:
    // Hierher wird gesprungen, wenn d0 <= d1
    // (Z.B. Füge Code für diesen Fall hinzu)
    b exit

greater:
    // Hierher wird gesprungen, wenn d0 > d1
    // (Z.B. Füge Code für diesen Fall hinzu)

 exit:
    // Exit system call
    mov x8, #93
    mov x0, #0
    svc 0

Wichtiger Hinweis:

  • fcmpe: Vergleich von Gleitkommazahlen nach IEEE 754.
  • fcmp: Vergleich von Gleitkommazahlen ohne Exception (unsicherer Vergleich).

Beide Vergleichsoperationen verwenden die gleichen Vergleichsflags (N, Z, C, V), wie bei Ganzzahlenvergleichen.

Abgerufen von „https://satyria.de/arm/index.php?title=Gleitkommaoperationen&oldid=1021“