Laden und Speichern von Werten

Laden und Speichern von Werten in ARM64-Assembler

In diesem Abschnitt werden wir ausführlich und verständlich die grundlegenden Konzepte des Ladens und Speicherns von Werten in ARM64-Assembler behandeln. Dies umfasst das Laden von konstanten und variablen Werten in Register sowie das Speichern von Registerwerten im Speicher. Wir werden die Befehle ldr und str detailliert besprechen. Diese Anleitung ist für Anfänger geschrieben und soll Ihnen helfen, die Grundlagen zu verstehen und anzuwenden.

Register und Speicher: Grundlagen

Register sind spezielle Speicherplätze in der CPU, die sehr schnell zugänglich sind. Sie dienen dazu, Daten während der Programmausführung zu speichern und zu manipulieren. ARM64-Prozessoren verfügen über 31 allgemeine Register, die jeweils 64 Bit groß sind und als x0 bis x30 bezeichnet werden.

Der Speicher hingegen ist eine größere, aber langsamer zugängliche Ressource, auf die mit Speicheradressen zugegriffen wird. Typischerweise werden Werte vom Speicher in Register geladen, um sie zu manipulieren, und anschließend wieder in den Speicher zurückgeschrieben.

Laden von konstanten Werten in Register

Wenn wir einen konstanten Wert in ein Register laden möchten, verwenden wir den mov-Befehl. Ein konstanten Wert ist ein fester Wert, der direkt im Assemblercode angegeben wird.

Beispiel: Laden des Werts 42 in das Register x0

mov x0, #42    // Lade den konstanten Wert 42 in das Register x0

Laden von variablen Werten in Register

Variable Werte sind solche, die im Speicher gespeichert sind und deren Werte sich ändern können. Um einen variablen Wert in ein Register zu laden, verwenden wir den ldr-Befehl.

Beispiel: Angenommen, wir haben eine Variable, die eine Ganzzahl speichert

.section .data
var:    .quad 12345    // Definition einer Variable im Datensegment mit dem Wert 12345

.section .text
.global _start

_start:
    ldr x0, =var       // Lade die Adresse der Variable `var` in das Register x0
    ldr x1, [x0]       // Lade den Wert der Adresse in x0 in das Register x1
    // Im Register x1 steht jetzt der Wert 12345

Speichern von Registerwerten im Speicher

Wenn wir einen Wert von einem Register in den Speicher speichern möchten, verwenden wir den str-Befehl.

Beispiel: Speichern eines Wertes in den Speicher

.section .data
var:    .quad 0        // Speicher für eine Variable im Datensegment

.section .text
.global _start

_start:
    mov x0, #6789      // Lade den Wert 6789 in das Register x0
    ldr x1, =var       // Lade die Adresse der Variable `var` in das Register x1
    str x0, [x1]       // Speichere den Wert aus x0 an der Adresse in x1 (in die Variable `var`)
    // Jetzt ist der Wert 6789 im Speicher an der Adresse von `var` gespeichert

Verwende hier im gdb den Befehl x /1h $x1 um den Speicherbereich auf den das Register x1 zeigt, anzuzeigen.

Laden und Speichern: Die Befehle ldr und str

ldr (load register): Dieser Befehl lädt einen Wert aus dem Speicher in ein Register.

Syntax: ldr <Zielregister>, [<Quelladresse>] Beispiel:

ldr x0, [x1] (Lade den Wert aus der Speicheradresse, die in x1 steht, in x0)

str (store register): Dieser Befehl speichert einen Wert aus einem Register in den Speicher.

Syntax: str <Quellregister>, [<Zieladresse>] Beispiel:

str x0, [x1] (Speichere den Wert aus x0 in die Speicheradresse, die in x1 steht)

Zusammenfassung

Um das Laden und Speichern von Werten in ARM64-Assembler zusammenzufassen:

Konstanten Werte laden

Verwenden Sie mov, um einen konstanten Wert in ein Register zu laden.

Beispiel: mov x0, #42

Variablen Werte laden

Verwenden Sie ldr, um einen Wert aus dem Speicher in ein Register zu laden.

Beispiel: ldr x0, [x1] //Vorausgesetzt, x1 enthält die Adresse des Werts

Registerwerte speichern

Verwenden Sie str, um einen Wert aus einem Register in den Speicher zu speichern.

Beispiel: str x0, [x1] //Vorausgesetzt, x1 enthält die Zieladresse im Speicher

Indem Sie diese grundlegenden Konzepte verstehen und anwenden, können Sie effektiv mit Werten in ARM64-Assembler arbeiten. Dieser Basisbaustein ist essenziell für die weitere Programmierung und Manipulation von Daten auf niedriger Ebene.

Relative Adressierung am PC

Warum relative Adressierung?

Relative Adressierung wird hauptsächlich aus folgenden Gründen verwendet:

• Portabilität: Programme können unabhängig vom Speicherort korrekt ausgeführt werden. Wenn der Programmcode verschoben wird (z.B. bei der Erstellung von Shared Libraries), kann er weiterhin korrekt auf Daten zugreifen.
• Effizienz: Relative Adressierung reduziert die Notwendigkeit für absolute Adressen und ermöglicht es dem Programm, geringeren Overhead und schnellere Ausführung zu haben.
• Größe und Umfang: ARM64 erlaubt eine relative Adressierung von ca. +/- 1 MB (19-Bit breit), was für viele Anwendungsfälle ausreichend ist und Speicher effizient nutzt.

Grenzen der relativen Adressierung

Die Hauptgrenze der relativen Adressierung liegt in der Reichweite:

• Bereich: Der relative Bereich zur Berechnung der Adresse ist auf ca. +/- 1 MB begrenzt. Für größere Bereiche müssen andere Techniken verwendet werden.
• Komplexität: Je komplexer das Programm, desto mehr Aufwand kann nötig sein, um sicherzustellen, dass alle relativen Adressen korrekt berechnet werden.

In diesem Abschnitt wird erklärt, wie Sie in einem ARM64-Bit-Assembler mit relativer Adressierung arbeiten können. Relatives Adressieren ermöglicht es dem Programm, Adressen im Verhältnis zum Program Counter (PC) zu berechnen. Dies ist nützlich, wenn Sie Variablen oder Datenstrukturen im Speicher des Programms ansprechen wollen.

Relative Adressierung mit ldr

Der Befehl ldr (Load Register) kann verwendet werden, um eine Adresse relativ zum aktuellen Program Counter (PC) zu laden. Eine übliche Art, dies zu tun, ist:

ldr x1, =hello

Hier wird die Adresse des Labels hello relativ zum Program Counter in das Register x1 geladen.

Datenabschnitt deklarieren

.data
hello:
    .ascii "Hallo"

In diesem Beispiel enthält der Datenbereich eine Zeichenkette "Hallo" mit dem Label hello.

Direkte 64-Bit-Zuweisung

Eine direkte 64-Bit-Zuweisung kann folgendermaßen erfolgen:

ldr x1, =0x1234567890abcdef

Dies wird vom Assembler in zwei Anweisungen aufgelöst:

ldr x1, #8
.quad 0x1234567890abcdef

So wird die Immediate-Adresse in den Code eingefügt. Der Assembler wählt automatisch die effizienteste Methode, um die 64-Bit-Konstante in das Register zu laden.

Typen des ldr-Befehls es weiteren

Der ldr-Befehl kann verschiedene Typen von Daten laden:

Typen

TYP	Bedeutung
B	Unsigned byte
SB	Signed byte
H	Unsigned halfword (16 bits)
SH	Signed halfword (16 bits)
SW	Signed word

Ein Beispiel:

ldr x0, =MeineZahl
ldr x0, [x0]

Hier wird die Adresse MeineZahl in x0 geladen und anschließend wird der Inhalt, der an dieser Adresse steht, in x0 gelesen.

Datenabschnitt mit einer Zahl

.data
MeineZahl: 
    .quad 0x1234567fe

Dies definiert eine 64-Bit-Zahl im Datenbereich.

Store Register (str)

Der str-Befehl benutzt eine ähnliche Syntax, um Daten aus einem Register in den Speicher zu schreiben:

str{x_typ} xt, [xa]

Hier steht {x_typ} für einen der oben genannten Datentypen (B, SB, H, SH, SW) und xt und xa sind die Register für die Daten und die Adresse.

Alternativen zur relativen Adressierung

Es gibt mehrere Alternativen zur relativen Adressierung, die je nach Bedarf verwendet werden können:

• Absolute Adressierung: Direktes Angeben der vollständigen Adresse im Speicher. Dies ist weniger flexibel, da es spezifisch für eine Speicherort ist.

mov x1, #0x1000    ; Absolute Adresse laden

• Base + Offset Adressierung: Kombination einer Basisadresse mit einem Offset. Dies ist besonders nützlich für Arrays und Strukturen.

mov x1, baseAddress
add x1, x1, offset

PC-relative Adressierung mit Ladebefehl:

ldr x1, [pc, #offset]

Hierbei wird der Wert aus dem Speicher relativ zum Program Counter geladen.

• Indirekte Adressierung: Verwenden eines Registers, das die Adresse speichert.

mov x0, #address
ldr x1, [x0]

Indexsierung (Arrays)

PseudoCode:

dim a[10] as word
a[5] = 10         //setze das 5 Element mit 10
x = a[8]          //Schreibe das 8 Element nach x
for i = 1 to 10
   a[i] = i *8
next

In Assembler:

 ldr x0,=MeinArray  //Lade die Adresse von MeinArray nach x0
 mov w1,#10         //Speichere 10 in w1 ab
 str w1,[x0,#(4*4)] //Speichere w1 in das 5 Element (Begin ist 0) (Word = 4 Byte) 
 ldr w1,[x0,#(7*4)] //lade das 8 Element nach w1
 mov w2,#1  //i=1
forloop:
 lsl w4,w2,#3             // i * 8
 str w4,[x0, w2, lsl #2]  // speichere der Wert aus w4 nach Basisadresse x0 mit index aus w2, der um 4 Multipliziert wird.
 add w2,w2,#1             // i=i+1
 cmp w2,#10               // if i<10
 b.le forloop

• Der Index kann auch negativ sein.

• Post-indexierte Adressierung

-> ldr x1,[x2], #4 //Holt den Wert aus x2 und erhöht anschließen x2 um 4

• ldp, stp -> 128-Bit

ldr x1,=GrosseZahl
ldp x2,x3,[x1]
stp x2,x3,[x1]
.data
GrosseZahl:
.octa 0x12345678901234567890123456789012