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

-> ldr PC-relativ Adresse 19-Bit breit (ca. +/-1MB) Beispiel:

 ldr x1,=hello
 ...
.data
hello:
.ascii "Hallo"

Die Adresse zum Label "hello" wird relativ zum PC ermittelt. -> TRICK:

 ldr x1,=0x1234567890abcdef //Direkte 64-Bit Zuweisung

Der Assembler wandelt diese Anweisung:

 ldr x1,#8
.quad 0x1234567890abcdef

• ldr{Typ} xt,[xa], wobei für Typ steht:

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

Beispiel:

 ldr x0,=MeineZahl //läd die Adresse meiner Variablen
 ldr x0,[x0]       //läd dann den Inhalt der Variablen
.data
MeineZahl: .quad 0x1234567fe

• str{Typ} xt,[xa]

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