Laden und Speichern von Werten - Versionsgeschichte

Satyria: /* Indexsierung (Arrays) */

2025-04-08T11:03:49Z

Indexsierung (Arrays)

← Nächstältere Version		Version vom 8. April 2025, 12:03 Uhr
Zeile 240:		Zeile 240:
	</syntaxhighlight>		</syntaxhighlight>

	Schritt für Schritt Erklärung:		'''Schritt für Schritt Erklärung''':

	Array-Adresse laden:		Array-Adresse laden:
			<syntaxhighlight lang="asm">
	ldr x0, =MeinArray		ldr x0, =MeinArray
			</syntaxhighlight>

	Hier wird die Anfangsadresse des Arrays MeinArray in das Register x0 geladen.		Hier wird die Anfangsadresse des Arrays MeinArray in das Register x0 geladen.

	Wert setzen:		Wert setzen:
			<syntaxhighlight lang="asm">
	mov w1, #10		mov w1, #10
	str w1, [x0, #(44)] // 44 weil das 5. Element bei Index 4 liegt (0-basiert)		str w1, [x0, #(44)] // 44 weil das 5. Element bei Index 4 liegt (0-basiert)
			</syntaxhighlight>

	Der Wert 10 wird in das 5. Element des Arrays MeinArray geschrieben.		Der Wert 10 wird in das 5. Element des Arrays MeinArray geschrieben.

	Wert lesen:		Wert lesen:
			<syntaxhighlight lang="asm">
	ldr w1, [x0, #(7*4)] // Lesen des 8. Elements (Index 7)		ldr w1, [x0, #(7*4)] // Lesen des 8. Elements (Index 7)
			</syntaxhighlight>

	Der Wert des 8. Elements (Index 7) wird in das Register w1 geladen.		Der Wert des 8. Elements (Index 7) wird in das Register w1 geladen.

	Schleife, um den Array zu füllen:		Schleife, um den Array zu füllen:
			<syntaxhighlight lang="asm">
	mov w2, #1		mov w2, #1
	forloop:		forloop:
Zeile 273:		Zeile 273:
	cmp w2, #10 // Vergleichen ob w2 < 10		cmp w2, #10 // Vergleichen ob w2 < 10
	b.le forloop // Wiederholen, bis w2 > 10		b.le forloop // Wiederholen, bis w2 > 10
			</syntaxhighlight>
	Post-indexierte Adressierung		=== Post-indexierte Adressierung ===

	Post-indexierte Adressierung ist eine Technik, bei der ein Register nicht nur verwendet wird, um eine Adresse zu bestimmen, sondern danach auch modifiziert wird. Hier ein Beispiel:		Post-indexierte Adressierung ist eine Technik, bei der ein Register nicht nur verwendet wird, um eine Adresse zu bestimmen, sondern danach auch modifiziert wird. Hier ein Beispiel:
			<syntaxhighlight lang="asm">
	ldr x1, [x2], #4 // Lese den Wert von der Adresse in x2 nach x1 und erhöhe x2 um 4		ldr x1, [x2], #4 // Lese den Wert von der Adresse in x2 nach x1 und erhöhe x2 um 4
			</syntaxhighlight>

	In diesem Fall wird die ursprüngliche Adresse verwendet, um den Wert zu laden, und dann wird die Adresse um 4 erhöht.		In diesem Fall wird die ursprüngliche Adresse verwendet, um den Wert zu laden, und dann wird die Adresse um 4 erhöht.

	128-Bit Laden und Speichern mit ldp und stp		=== 128-Bit Laden und Speichern mit ldp und stp ===

	Die Befehle ldp (load pair) und stp (store pair) können verwendet werden, um 128-Bit-Daten (zwei 64-Bit-Register) zu laden und zu speichern:		Die Befehle ldp (load pair) und stp (store pair) können verwendet werden, um 128-Bit-Daten (zwei 64-Bit-Register) zu laden und zu speichern:

	Laden		* Laden
			<syntaxhighlight lang="asm">
	ldr x1, =GrosseZahl		ldr x1, =GrosseZahl
	ldp x2, x3, [x1] // Lese 128 Bit (in x2 und x3), beginnend bei der Adresse in x1		ldp x2, x3, [x1] // Lese 128 Bit (in x2 und x3), beginnend bei der Adresse in x1
			</syntaxhighlight>

			* Speichern
	Speichern		<syntaxhighlight lang="asm">

	stp x2, x3, [x1] // Speichere 128 Bit (x2 und x3) an die Adresse in x1		stp x2, x3, [x1] // Speichere 128 Bit (x2 und x3) an die Adresse in x1
			</syntaxhighlight>

			* Datenabschnitt
	Datenabschnitt		<syntaxhighlight lang="asm">

	.data		.data
	GrosseZahl:		GrosseZahl:
	.octa 0x12345678901234567890123456789012		.octa 0x12345678901234567890123456789012
			</syntaxhighlight>

	Diese Anweisungen sind besonders nützlich für Manipulationen an großen Datenmengen und erlauben effizientere Speicheroperationen.		Diese Anweisungen sind besonders nützlich für Manipulationen an großen Datenmengen und erlauben effizientere Speicheroperationen.

	Zusammenfassung		=== Zusammenfassung ===

	Indizierung erlaubt es, auf Elemente eines Arrays zuzugreifen und sie zu manipulieren. Relative und post-indexierte Adressierung bieten Methoden, um Speicher effizient zu verwenden. Das Laden und Speichern mit ldp und stp ermöglicht die Handhabung von 128-Bit-Daten, um Speicheroperationen schneller und kompakter zu gestalten.		Indizierung erlaubt es, auf Elemente eines Arrays zuzugreifen und sie zu manipulieren. Relative und post-indexierte Adressierung bieten Methoden, um Speicher effizient zu verwenden. Das Laden und Speichern mit ldp und stp ermöglicht die Handhabung von 128-Bit-Daten, um Speicheroperationen schneller und kompakter zu gestalten.






	~~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~~

Satyria: /* Indexsierung (Arrays) */

2025-04-08T08:45:27Z

Indexsierung (Arrays)

@@ Zeile 208: / Zeile 208: @@
 == Indexsierung (Arrays) ==
 PseudoCode:
   dim a[10] as word

Satyria: /* Relative Adressierung am PC */

2025-04-08T08:38:42Z

Relative Adressierung am PC

Änderungen zeigen

Satyria: /* Relative Adressierung am PC */

2025-04-08T08:29:25Z

Relative Adressierung am PC

Satyria: /* Relative Adressierung am PC */

2025-04-08T08:27:01Z

Relative Adressierung am PC

Änderungen zeigen

Satyria am 8. April 2025 um 06:58 Uhr

2025-04-08T06:58:41Z

← Nächstältere Version		Version vom 8. April 2025, 07:58 Uhr
Zeile 85:		Zeile 85:

	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.		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

Satyria: /* Beispiel: Speichern eines Wertes in den Speicher */

2025-04-03T08:10:53Z

Beispiel: Speichern eines Wertes in den Speicher

← Nächstältere Version		Version vom 3. April 2025, 09:10 Uhr
Zeile 48:		Zeile 48:
	</syntaxhighlight>		</syntaxhighlight>

	Verwende hier im <syntaxhighlight lang="shell" inline>gdb x /1h $x1</syntaxhighlight> um den Speicherbereich auf den das Register '''x1''' zeigt, anzuzeigen.		Verwende hier im <syntaxhighlight lang="shell" inline>gdb</syntaxhighlight> den Befehl <syntaxhighlight lang="shell" inline>x /1h $x1</syntaxhighlight> um den Speicherbereich auf den das Register '''x1''' zeigt, anzuzeigen.

	== Laden und Speichern: Die Befehle ldr und str ==		== Laden und Speichern: Die Befehle ldr und str ==

Satyria: /* Beispiel: Speichern eines Wertes in den Speicher */

2025-04-03T08:09:53Z

Beispiel: Speichern eines Wertes in den Speicher

← Nächstältere Version		Version vom 3. April 2025, 09:09 Uhr
Zeile 48:		Zeile 48:
	</syntaxhighlight>		</syntaxhighlight>

	Verwende hier im <syntaxhighlight lang="shell" inline>gdb~~</syntaxhighlight> <syntaxhighlight lang="gdb" inline>~~x /1h $x1</syntaxhighlight> um den Speicherbereich auf den das Register '''x1''' zeigt, anzuzeigen.		Verwende hier im <syntaxhighlight lang="shell" inline>gdb x /1h $x1</syntaxhighlight> um den Speicherbereich auf den das Register '''x1''' zeigt, anzuzeigen.

	== Laden und Speichern: Die Befehle ldr und str ==		== Laden und Speichern: Die Befehle ldr und str ==

Satyria: /* Beispiel: Speichern eines Wertes in den Speicher */

2024-12-01T15:47:06Z

Beispiel: Speichern eines Wertes in den Speicher

← Nächstältere Version		Version vom 1. Dezember 2024, 16:47 Uhr
Zeile 48:		Zeile 48:
	</syntaxhighlight>		</syntaxhighlight>

	Verwende hier im gdb x /1h $x1 um den Speicherbereich auf den das Register x1 zeigt, anzuzeigen.		Verwende hier im <syntaxhighlight lang="shell" inline>gdb</syntaxhighlight> <syntaxhighlight lang="gdb" inline>x /1h $x1</syntaxhighlight> um den Speicherbereich auf den das Register '''x1''' zeigt, anzuzeigen.

	== Laden und Speichern: Die Befehle ldr und str ==		== Laden und Speichern: Die Befehle ldr und str ==

Satyria: /* Beispiel: Speichern eines Wertes in den Speicher */

2024-12-01T15:45:10Z

Beispiel: Speichern eines Wertes in den Speicher

← Nächstältere Version		Version vom 1. Dezember 2024, 16:45 Uhr
Zeile 47:		Zeile 47:
	// Jetzt ist der Wert 6789 im Speicher an der Adresse von `var` gespeichert		// Jetzt ist der Wert 6789 im Speicher an der Adresse von `var` gespeichert
	</syntaxhighlight>		</syntaxhighlight>

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

	== Laden und Speichern: Die Befehle ldr und str ==		== Laden und Speichern: Die Befehle ldr und str ==
	<syntaxhighlight lang="asm" inline>ldr</syntaxhighlight> (''load register''): Dieser Befehl lädt einen Wert aus dem Speicher in ein Register.		<syntaxhighlight lang="asm" inline>ldr</syntaxhighlight> (''load register''): Dieser Befehl lädt einen Wert aus dem Speicher in ein Register.

← Nächstältere Version		Version vom 8. April 2025, 09:29 Uhr
Zeile 87:		Zeile 87:

	== Relative Adressierung am PC ==		== Relative Adressierung am PC ==
	~~Einführung in die Relative Adressierung im ARM64-Bit-Assembler.~~		=== Warum relative Adressierung? ===

	Warum relative Adressierung?
	Relative Adressierung wird hauptsächlich aus folgenden Gründen verwendet:		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.		* 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.		* 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.		* 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		=== Grenzen der relativen Adressierung ===
	Die Hauptgrenze der relativen Adressierung liegt in der Reichweite:		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.		* 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.		* 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.		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		=== 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:		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: