Lade- und Speicheranweisungen: Unterschied zwischen den Versionen

Aus C und Assembler mit Raspberry
Die Seite wurde neu angelegt: „Die "Lade- und Speicheranweisungen" im ARMv8 sind essenziell für den Zugriff auf den Speicher, sowohl um Daten zu lesen (Load) als auch zu schreiben (Store). Diese Anweisungen sind entscheidend für jede Art von Datenverarbeitung. == Grundlegendes == In der ARMv8-Architektur bedeutet "Load" das Laden von Daten aus dem Speicher in Register, während "Store" das Schreiben von Daten aus Register in den Speicher bedeutet. Dabei unterstützen "Loads and Stor…“
 
KKeine Bearbeitungszusammenfassung
Zeile 8: Zeile 8:


* LDR (Load Register):
* LDR (Load Register):
: Format: LDR <Rt>, [<Rn>, #<imm>]
: Format: <code>LDR <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: LDR X0, [X1, #8]
: Beispiel: <code>LDR X0, [X1, #8]</code>
: Erklärung: Lädt den Wert, der sich 8 Bytes nach der Adresse in X1 befindet, in das Register X0.
: Erklärung: Lädt den Wert, der sich 8 Bytes nach der Adresse in <code>X1</code> befindet, in das Register <code>X0</code>.


* LDRB (Load Register Byte):
* LDRB (Load Register Byte):
: Format: LDRB <Rt>, [<Rn>, #<imm>]
: Format: <code>LDRB <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: LDRB W0, [X1, #2]
: Beispiel: <code>LDRB W0, [X1, #2]</code>
: Erklärung: Lädt ein Byte, das sich 2 Bytes nach der Adresse in X1 befindet, in das Register W0.
: Erklärung: Lädt ein Byte, das sich 2 Bytes nach der Adresse in <code>X1</code> befindet, in das Register <code>W0</code>.


* LDRH (Load Register Halfword):
* LDRH (Load Register Halfword):
: Format: LDRH <Rt>, [<Rn>, #<imm>]
: Format: <code>LDRH <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: LDRH W0, [X1, #4]
: Beispiel: <code>LDRH W0, [X1, #4]</code>
: Erklärung: Lädt ein Halbwort (16 Bit), das sich 4 Bytes nach der Adresse in X1 befindet, in das Register W0.
: Erklärung: Lädt ein Halbwort (16 Bit), das sich 4 Bytes nach der Adresse in <code>X1</code> befindet, in das Register <code>W0</code>.


* LDP (Load Pair):
* LDP (Load Pair):
: Format: LDP <Rt>, <Rt2>, [<Rn>, #<imm>]
: Format: <code>LDP <Rt>, <Rt2>, [<Rn>, #<imm>]</code>
: Beispiel: LDP X0, X1, [X2, #16]
: Beispiel: <code>LDP X0, X1, [X2, #16]</code>
: Erklärung: Lädt zwei aufeinanderfolgende Register (X0 und X1) aus dem Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in X2 liegt.
: Erklärung: Lädt zwei aufeinanderfolgende Register (<code>X0</code> und <code>X1</code>) aus dem Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in <code>X2</code> liegt.


== Stores (Schreiboperationen) ==
== Stores (Schreiboperationen) ==
Zeile 31: Zeile 31:


* STR (Store Register):
* STR (Store Register):
: Format: STR <Rt>, [<Rn>, #<imm>]
: Format: <code>STR <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: STR X0, [X1, #8]
: Beispiel: <code>STR X0, [X1, #8]</code>
: Erklärung: Speichert den Wert in X0 an die Adresse, die 8 Bytes nach der Adresse in X1 liegt.
: Erklärung: Speichert den Wert in <code>X0</code> an die Adresse, die 8 Bytes nach der Adresse in <code>X1</code> liegt.


* STRB (Store Register Byte):
* STRB (Store Register Byte):
: Format: STRB <Rt>, [<Rn>, #<imm>]
: Format: <code>STRB <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: STRB W0, [X1, #2]
: Beispiel: <code>STRB W0, [X1, #2]</code>
: Erklärung: Speichert ein Byte aus W0 an die Adresse, die sich 2 Bytes nach X1 befindet.
: Erklärung: Speichert ein Byte aus <code>W0</code> an die Adresse, die sich 2 Bytes nach <code>X1</code> befindet.


* STRH (Store Register Halfword):
* STRH (Store Register Halfword):
: Format: STRH <Rt>, [<Rn>, #<imm>]
: Format: <code>STRH <Rt>, [<Rn>, #<imm>]</code>
: Beispiel: STRH W0, [X1, #4]
: Beispiel: <code>STRH W0, [X1, #4]</code>
: Erklärung: Speichert ein Halbwort aus W0 an die Adresse, die sich 4 Bytes nach X1 befindet.
: Erklärung: Speichert ein Halbwort aus <code>W0</code> an die Adresse, die sich 4 Bytes nach <code>X1</code> befindet.


* STP (Store Pair):
* STP (Store Pair):
: Format: STP <Rt>, <Rt2>, [<Rn>, #<imm>]
: Format: <code>STP <Rt>, <Rt2>, [<Rn>, #<imm>]</code>
: Beispiel: STP X0, X1, [X2, #16]
: Beispiel: <code>STP X0, X1, [X2, #16]</code>
: Erklärung: Speichert zwei aufeinanderfolgende Register (X0 und X1) in den Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in X2 liegt.
: Erklärung: Speichert zwei aufeinanderfolgende Register (<code>X0</code> und <code>X1</code>) in den Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in <code>X2</code> liegt.


== Atomare Operationen ==
== Atomare Operationen ==
Zeile 54: Zeile 54:


* LDXR/STXR (Exclusive Load/Store Register):
* LDXR/STXR (Exclusive Load/Store Register):
: Format (LDXR): LDXR <Rt>, [<Rn>]
: Format <code>(LDXR): LDXR <Rt>, [<Rn>]</code>
: Format (STXR): STXR <Ws>, <Rt>, [<Rn>]
: Format <code>(STXR): STXR <Ws>, <Rt>, [<Rn>]</code>
: Beispiel:
: Beispiel:
:<syntaxhighlight lang="asm">
:<syntaxhighlight lang="asm">
Zeile 61: Zeile 61:
STXR W2, X0, [X1]
STXR W2, X0, [X1]
</syntaxhighlight>
</syntaxhighlight>
: Erklärung: LDXR lädt den Wert aus der Adresse X1 in X0. STXR speichert den Wert von X0 an die Adresse X1 und setzt W2 auf 0, wenn der Store erfolgreich war.
: Erklärung: <code>LDXR</code> lädt den Wert aus der Adresse <code>X1</code> in <code>X0</code>. <code>STXR</code> speichert den Wert von <code>X0</code> an die Adresse <code>X1</code> und setzt <code>W2</code> auf 0, wenn der Store erfolgreich war.

Version vom 26. September 2024, 11:10 Uhr

Die "Lade- und Speicheranweisungen" im ARMv8 sind essenziell für den Zugriff auf den Speicher, sowohl um Daten zu lesen (Load) als auch zu schreiben (Store). Diese Anweisungen sind entscheidend für jede Art von Datenverarbeitung.

Grundlegendes

In der ARMv8-Architektur bedeutet "Load" das Laden von Daten aus dem Speicher in Register, während "Store" das Schreiben von Daten aus Register in den Speicher bedeutet. Dabei unterstützen "Loads and Stores" verschiedene Datenformate und Adressierungsmodi.

Loads (Leseoperationen)

Hier sind einige der wichtigsten Load-Instruktionen:

  • LDR (Load Register):
Format: LDR , [<Rn>, #<imm>]
Beispiel: LDR X0, [X1, #8]
Erklärung: Lädt den Wert, der sich 8 Bytes nach der Adresse in X1 befindet, in das Register X0.
  • LDRB (Load Register Byte):
Format: LDRB , [<Rn>, #<imm>]
Beispiel: LDRB W0, [X1, #2]
Erklärung: Lädt ein Byte, das sich 2 Bytes nach der Adresse in X1 befindet, in das Register W0.
  • LDRH (Load Register Halfword):
Format: LDRH , [<Rn>, #<imm>]
Beispiel: LDRH W0, [X1, #4]
Erklärung: Lädt ein Halbwort (16 Bit), das sich 4 Bytes nach der Adresse in X1 befindet, in das Register W0.
  • LDP (Load Pair):
Format: LDP , <Rt2>, [<Rn>, #<imm>]
Beispiel: LDP X0, X1, [X2, #16]
Erklärung: Lädt zwei aufeinanderfolgende Register (X0 und X1) aus dem Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in X2 liegt.

Stores (Schreiboperationen)

Hier sind einige der wichtigsten Store-Instruktionen:

  • STR (Store Register):
Format: STR , [<Rn>, #<imm>]
Beispiel: STR X0, [X1, #8]
Erklärung: Speichert den Wert in X0 an die Adresse, die 8 Bytes nach der Adresse in X1 liegt.
  • STRB (Store Register Byte):
Format: STRB , [<Rn>, #<imm>]
Beispiel: STRB W0, [X1, #2]
Erklärung: Speichert ein Byte aus W0 an die Adresse, die sich 2 Bytes nach X1 befindet.
  • STRH (Store Register Halfword):
Format: STRH , [<Rn>, #<imm>]
Beispiel: STRH W0, [X1, #4]
Erklärung: Speichert ein Halbwort aus W0 an die Adresse, die sich 4 Bytes nach X1 befindet.
  • STP (Store Pair):
Format: STP , <Rt2>, [<Rn>, #<imm>]
Beispiel: STP X0, X1, [X2, #16]
Erklärung: Speichert zwei aufeinanderfolgende Register (X0 und X1) in den Speicher, beginnend bei der Adresse, die 16 Bytes nach dem Wert in X2 liegt.

Atomare Operationen

ARMv8 unterstützt auch atomare Lade- und Speicherinstruktionen, die bei der Implementierung von Synchronisationsmechanismen wichtig sind:

  • LDXR/STXR (Exclusive Load/Store Register):
Format (LDXR): LDXR , [<Rn>]
Format (STXR): STXR <Ws>, , [<Rn>]
Beispiel:
LDXR X0, [X1]
STXR W2, X0, [X1]
Erklärung: LDXR lädt den Wert aus der Adresse X1 in X0. STXR speichert den Wert von X0 an die Adresse X1 und setzt W2 auf 0, wenn der Store erfolgreich war.