Aliase - Versionsgeschichte

Satyria am 11. April 2025 um 05:41 Uhr

2025-04-11T05:41:15Z

← Nächstältere Version		Version vom 11. April 2025, 06:41 Uhr
Zeile 137:		Zeile 137:
	Du siehst:		Du siehst:

	\| Quellcode Alias \| Disassembler zeigt \| Bedeutung \|		{\| class="wikitable"
	\|-~~---------------------\|------------------------\|---------------------------------------------\|~~		\|-
	\| `mov x0, x1` \| `orr x0, x1, xzr` \| Kopiere x1 nach x0 \|		! Quellcode Alias !! Disassembler zeigt !! Bedeutung
	\| `mov x2, #0` \| `movz x2, #0x0` \| Setze x2 auf 0 \|		\|-
	\| `cmp x0, x1` \| `subs xzr, x0, x1` \| Vergleiche x0 mit x1 \|		\| `mov x0, x1` \|\| `orr x0, x1, xzr` \|\| Kopiere x1 nach x0
	\| `neg x3, x4` \| `sub x3, xzr, x4` \| x3 = -x4 \|		\|-
	\| `nop` \| `hint #0` \| Kein Effekt \|		\| `mov x2, #0` \|\| `movz x2, #0x0` \|\| Setze x2 auf 0
	\| `ret` \| `ret` \| Rücksprung über x30 \|		\|-
			\| `cmp x0, x1` \|\| `subs xzr, x0, x1` \|\| Vergleiche x0 mit x1
			\|-
			\| `neg x3, x4` \|\| `sub x3, xzr, x4` \|\| x3 = -x4
			\|-
			\| `nop` \|\| `hint #0` \|\| Kein Effekt
			\|-
			\| `ret` \|\| `ret` \|\| Rücksprung über x30
			\|}


	=== Weitere Analyse ===		=== Weitere Analyse ===

Satyria am 11. April 2025 um 05:36 Uhr

2025-04-11T05:36:03Z

← Nächstältere Version		Version vom 11. April 2025, 06:36 Uhr
Zeile 59:		Zeile 59:
	== Bekannte Aliase im ARM64-Assembler ==		== Bekannte Aliase im ARM64-Assembler ==

	\| Alias \| Entsprechender Instruktionscode \| Beschreibung \|		{\| class="wikitable"
	\|-~~---------------\|------------------------------------------------\|------------------------------------------\|~~		\|-
	\| `mov x0, x1` \| `orr x0, x1, xzr` \| Kopiere Register \|		! Alias !! Entsprechender Instruktionscode !! Beschreibung
	\| `mov x0, #0` \| `movz x0, #0` \| Setze Register auf 0 \|		\|-
	\| `cmp x0, x1` \| `subs xzr, x0, x1` \| Vergleich über Subtraktion ohne Ergebnis \|		\| `mov x0, x1` \|\| `orr x0, x1, xzr` \|\| Kopiere Register
	\| `neg x0, x1` \| `sub x0, xzr, x1` \| Negation \|		\|-
	\| `nop` \| `hint #0` \| Kein-Operation (für Alignment etc.) \|		\| `mov x0, #0` \|\| `movz x0, #0` \|\| Setze Register auf 0
	\| `ret` \| `br x30` \| Rücksprung aus Funktion \|		\|-
	\| `b label` \| `b label` (kein Alias) \| Unbedingter Sprung \|		\| `cmp x0, x1` \|\| `subs xzr, x0, x1` \|\| Vergleich über Subtraktion ohne Ergebnis
	\| `bl label` \| `bl label` (kein Alias) \| Sprung mit Link (Funktionsaufruf) \|		\|-
	\| `movk/movz/movn`\| Literalladen in 16-Bit-Chunks \| Register initialisieren mit Immediate \|		\| `neg x0, x1` \|\| `sub x0, xzr, x1` \|\| Negation
			\|-
			\| `nop` \|\| `hint #0` \|\| Kein-Operation (für Alignment etc.)
			\|-
			\| `ret` \|\| `br x30` \|\| Rücksprung aus Funktion
			\|-
			\| `b label` \|\| `b label` (kein Alias) \|\| Unbedingter Sprung
			\|-
			\| `bl label` \|\| `bl label` (kein Alias) \|\| Sprung mit Link (Funktionsaufruf)
			\|-
			\| `movk/movz/movn`\|\| Literalladen in 16-Bit-Chunks \|\| Register initialisieren mit Immediate
			\|}

	== Warum ist das wichtig? ==		== Warum ist das wichtig? ==

Satyria am 10. April 2025 um 16:29 Uhr

2025-04-10T16:29:42Z

← Nächstältere Version		Version vom 10. April 2025, 17:29 Uhr
Zeile 16:		Zeile 16:

	Der Befehl `orr` (bitweises ODER) mit dem Wert `xzr` (Zero-Register) ergibt effektiv `mov`.		Der Befehl `orr` (bitweises ODER) mit dem Wert `xzr` (Zero-Register) ergibt effektiv `mov`.

	~~---~~

	== Warum macht man das? ==		== Warum macht man das? ==

	- Lesbarkeit: `mov x0, x1` ist leichter verständlich als `orr x0, x1, xzr`.		* Lesbarkeit: `mov x0, x1` ist leichter verständlich als `orr x0, x1, xzr`.
	- Portabilität: Viele Architekturen haben einen `mov`, und Entwickler erwarten diesen.		* Portabilität: Viele Architekturen haben einen `mov`, und Entwickler erwarten diesen.
	- Compilerfreundlich: Auch Compiler wie `clang` oder `gcc` generieren „Alias-ähnlichen“ Code.		* Compilerfreundlich: Auch Compiler wie `clang` oder `gcc` generieren „Alias-ähnlichen“ Code.

	~~---~~

	== Was macht `objdump` daraus? ==		== Was macht `objdump` daraus? ==

	Beim Disassemblieren mit `objdump` oder `gdb` siehst du immer den echten Maschinenbefehl, nicht den Alias.		Beim Disassemblieren mit `objdump` oder `gdb` siehst du "immer den echten Maschinenbefehl", nicht den Alias.

	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
	mov x0, x1 ; geschrieben im Assembler		mov x0, x1 // geschrieben im Assembler
	</syntaxhighlight>		</syntaxhighlight>

Zeile 40:		Zeile 36:
	</syntaxhighlight>		</syntaxhighlight>

	⚠️ Das kann verwirrend sein, wenn du Quellcode und disassemblierten Code vergleichst!		Das kann verwirrend sein, wenn du Quellcode und disassemblierten Code vergleichst!

	~~---~~

	== Was wird wirklich generiert? ==		== Was wird wirklich generiert? ==
Zeile 48:		Zeile 42:
	Nehmen wir `mov x0, x1`:		Nehmen wir `mov x0, x1`:

	- Quelltext (Alias):		* Quelltext (Alias):
	<syntaxhighlight lang="asm">		: <syntaxhighlight lang="asm">
	mov x0, x1		mov x0, x1
	</syntaxhighlight>		</syntaxhighlight>
	- Assembler-Expansion:		* Assembler-Expansion:
	<syntaxhighlight lang="asm">		: <syntaxhighlight lang="asm">
	orr x0, x1, xzr		orr x0, x1, xzr
	</syntaxhighlight>		</syntaxhighlight>
	- Maschinencode (Hex):		* Maschinencode (Hex):
	<syntaxhighlight lang="asm">		: <syntaxhighlight lang="asm">
	0xaa0103e0		0xaa0103e0
	</syntaxhighlight>		</syntaxhighlight>

	➡️ Ob du `mov x0, x1` oder `orr x0, x1, xzr` schreibst, ergibt denselben Maschinencode.		Ob du `mov x0, x1` oder `orr x0, x1, xzr` schreibst, ergibt "denselben Maschinencode".

	~~---~~

	== Bekannte Aliase im ARM64-Assembler ==		== Bekannte Aliase im ARM64-Assembler ==
Zeile 78:		Zeile 70:
	\| `bl label` \| `bl label` (kein Alias) \| Sprung mit Link (Funktionsaufruf) \|		\| `bl label` \| `bl label` (kein Alias) \| Sprung mit Link (Funktionsaufruf) \|
	\| `movk/movz/movn`\| Literalladen in 16-Bit-Chunks \| Register initialisieren mit Immediate \|		\| `movk/movz/movn`\| Literalladen in 16-Bit-Chunks \| Register initialisieren mit Immediate \|

	~~---~~

	== Warum ist das wichtig? ==		== Warum ist das wichtig? ==

	1. Disassembler zeigen keine Aliase → verwirrend bei Analyse.		# Disassembler zeigen keine Aliase → verwirrend bei Analyse.
	2. Debugging wird leichter, wenn man den echten Maschinenbefehl kennt.		# Debugging wird leichter, wenn man den echten Maschinenbefehl kennt.
	3. Assemblerfehler können entstehen, wenn man glaubt, `mov` sei ein „echter“ Befehl mit eigenen Regeln.		# Assemblerfehler können entstehen, wenn man glaubt, `mov` sei ein „echter“ Befehl mit eigenen Regeln.

	~~---~~
	Hier ist ein einfaches Beispielprogramm in ARM64-Assembler mit typischen Alias-Instruktionen, das du kompilieren und mit `objdump` untersuchen kannst. Danach zeige ich dir, wie die `objdump`-Ausgabe dazu aussieht.

	~~---~~

	== Beispiel: `alias_test.s` ==		== Beispiel: `alias_test.s` ==
			Hier ist ein einfaches Beispielprogramm in ARM64-Assembler mit typischen "Alias-Instruktionen", das du kompilieren und mit `objdump` untersuchen kannst. Danach zeige ich dir, wie die `objdump`-Ausgabe dazu aussieht.

	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
Zeile 117:		Zeile 103:
	ret		ret
	</syntaxhighlight>		</syntaxhighlight>

	~~---~~

	=== Bauen und disassemblieren ===		=== Bauen und disassemblieren ===
Zeile 127:		Zeile 111:
	objdump -d alias_test		objdump -d alias_test
	</syntaxhighlight>		</syntaxhighlight>

	~~---~~

	=== Beispielausgabe von `objdump -d alias_test` ===		=== Beispielausgabe von `objdump -d alias_test` ===
Zeile 152:		Zeile 134:
	\| `nop` \| `hint #0` \| Kein Effekt \|		\| `nop` \| `hint #0` \| Kein Effekt \|
	\| `ret` \| `ret` \| Rücksprung über x30 \|		\| `ret` \| `ret` \| Rücksprung über x30 \|

	~~---~~

	=== Weitere Analyse ===		=== Weitere Analyse ===

	Wenn du keine Aliase im Disassembly möchtest (d. h. nur „echte“ Instruktionen), kannst du `objdump` so verwenden:		Wenn du "keine Aliase im Disassembly" möchtest (d. h. nur „echte“ Instruktionen), kannst du `objdump` so verwenden:

	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
Zeile 163:		Zeile 143:
	</syntaxhighlight>		</syntaxhighlight>

	Das zeigt dir, wie es der CPU intern wirklich vorliegt.		Das zeigt dir, wie es "der CPU intern" wirklich vorliegt.

Satyria am 10. April 2025 um 16:22 Uhr

2025-04-10T16:22:49Z

← Nächstältere Version		Version vom 10. April 2025, 17:22 Uhr
Zeile 1:		Zeile 1:
	== Was sind Aliase? ==		== Was sind Aliase? ==

	Ein Alias ist eine alternative Schreibweise für eine Instruktion – sozusagen ein „freundlicher“ Name für komplexere Maschinenbefehle. Aliase machen den Code lesbarer und intuitiver, verändern aber nicht den Maschinencode, der letztlich generiert wird.		Ein "Alias" ist eine alternative Schreibweise für eine Instruktion – sozusagen ein „freundlicher“ Name für komplexere Maschinenbefehle. Aliase machen den Code "lesbarer und intuitiver", verändern aber "nicht" den Maschinencode, der letztlich generiert wird.

	Beispiel:		Beispiel:

	~~```~~asm		<syntaxhighlight lang="asm">
	mov x0, x1		mov x0, x1
	~~```~~		</syntaxhighlight>

	Dieser Befehl existiert nicht als eigener Maschinenbefehl, sondern ist ein Alias für:		Dieser Befehl existiert "nicht als eigener Maschinenbefehl", sondern ist ein "Alias" für:

	~~```~~asm		<syntaxhighlight lang="asm">
	orr x0, x1, xzr		orr x0, x1, xzr
	~~```~~		</syntaxhighlight>

	Der Befehl `orr` (bitweises ODER) mit dem Wert `xzr` (Zero-Register) ergibt effektiv `mov`.		Der Befehl `orr` (bitweises ODER) mit dem Wert `xzr` (Zero-Register) ergibt effektiv `mov`.
Zeile 31:		Zeile 31:
	Beim Disassemblieren mit `objdump` oder `gdb` siehst du immer den echten Maschinenbefehl, nicht den Alias.		Beim Disassemblieren mit `objdump` oder `gdb` siehst du immer den echten Maschinenbefehl, nicht den Alias.

	~~```~~asm		<syntaxhighlight lang="asm">
	mov x0, x1 ; geschrieben im Assembler		mov x0, x1 ; geschrieben im Assembler
	~~```~~		</syntaxhighlight>

	Ergibt in `objdump -d`:		Ergibt in `objdump -d`:
	~~```~~		<syntaxhighlight lang="asm">
	orr x0, x1, xzr		orr x0, x1, xzr
	~~```~~		</syntaxhighlight>

	⚠️ Das kann verwirrend sein, wenn du Quellcode und disassemblierten Code vergleichst!		⚠️ Das kann verwirrend sein, wenn du Quellcode und disassemblierten Code vergleichst!
Zeile 49:		Zeile 49:

	- Quelltext (Alias):		- Quelltext (Alias):
	~~```~~asm		<syntaxhighlight lang="asm">
	mov x0, x1		mov x0, x1
	~~```~~		</syntaxhighlight>
	- Assembler-Expansion:		- Assembler-Expansion:
	~~```~~asm		<syntaxhighlight lang="asm">
	orr x0, x1, xzr		orr x0, x1, xzr
	~~```~~		</syntaxhighlight>
	- Maschinencode (Hex):		- Maschinencode (Hex):
	~~```text~~		<syntaxhighlight lang="asm">
	0xaa0103e0		0xaa0103e0
	~~```~~		</syntaxhighlight>

	➡️ Ob du `mov x0, x1` oder `orr x0, x1, xzr` schreibst, ergibt denselben Maschinencode.		➡️ Ob du `mov x0, x1` oder `orr x0, x1, xzr` schreibst, ergibt denselben Maschinencode.
Zeile 94:		Zeile 94:
	== Beispiel: `alias_test.s` ==		== Beispiel: `alias_test.s` ==

	~~```~~asm		<syntaxhighlight lang="asm">
	.section .text		.section .text
	.global _start		.global _start
Zeile 116:		Zeile 116:
	// Alias: ret -> br x30		// Alias: ret -> br x30
	ret		ret
	~~```~~		</syntaxhighlight>

	---		---
Zeile 122:		Zeile 122:
	=== Bauen und disassemblieren ===		=== Bauen und disassemblieren ===

	~~```bash~~		<syntaxhighlight lang="shell">
	as alias_test.s -o alias_test.o		as alias_test.s -o alias_test.o
	ld alias_test.o -o alias_test		ld alias_test.o -o alias_test
	objdump -d alias_test		objdump -d alias_test
	~~```~~		</syntaxhighlight>

	---		---
Zeile 132:		Zeile 132:
	=== Beispielausgabe von `objdump -d alias_test` ===		=== Beispielausgabe von `objdump -d alias_test` ===

	~~```~~asm		<syntaxhighlight lang="asm">
	0000000000401000 <_start>:		0000000000401000 <_start>:
	401000: aa0103e0 orr x0, x1, xzr		401000: aa0103e0 orr x0, x1, xzr
Zeile 140:		Zeile 140:
	401010: d503201f nop		401010: d503201f nop
	401014: d65f03c0 ret		401014: d65f03c0 ret
	~~```~~		</syntaxhighlight>

	Du siehst:		Du siehst:
Zeile 159:		Zeile 159:
	Wenn du keine Aliase im Disassembly möchtest (d. h. nur „echte“ Instruktionen), kannst du `objdump` so verwenden:		Wenn du keine Aliase im Disassembly möchtest (d. h. nur „echte“ Instruktionen), kannst du `objdump` so verwenden:

	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -d -M no-aliases alias_test		objdump -d -M no-aliases alias_test
	~~```~~		</syntaxhighlight>

	Das zeigt dir, wie es der CPU intern wirklich vorliegt.		Das zeigt dir, wie es der CPU intern wirklich vorliegt.

Satyria am 10. April 2025 um 16:17 Uhr

2025-04-10T16:17:41Z

Änderungen zeigen

Satyria am 8. April 2025 um 06:49 Uhr

2025-04-08T06:49:07Z

← Nächstältere Version		Version vom 8. April 2025, 07:49 Uhr
Zeile 1:		Zeile 1:
	== Aliase ==		== Aliase ==
			== Laden von Registern ==
			-> mov x0,x1; Ein Alias. Gleiche ist möglich mit add x0, xzr, x1, aber tatsächlich ist es orr x0,xzr,x1

			Sourcecode:
			mov x1,#100
			mov x xzr, x1
			mov x1,#300
			orr x0,xzr,x1

			0000000000000000 <_start>:
			0: d2800c81 mov x1, #0x64 // #100
			4: aa0103e0 mov x0, x1
			8: d2801901 mov x1, #0xc8 // #200
			c: 8b0103e0 add x0, xzr, x1
			10: d2802581 mov x1, #0x12c // #300
			14: aa0103e0 mov x0, x1
			18: d2800000 mov x0, #0x0 // #0
			1c: d2800ba8 mov x8, #0x5d // #93
			20: d4000001 svc #0x0
			0,x1
			mov x1,#200
			add x0,

	-> Verwendung von Aliase, um den Code besser zu verstehen, Problem beim debuggen, objdump, da eventuell andere Aliases verwendet werden.		-> Verwendung von Aliase, um den Code besser zu verstehen, Problem beim debuggen, objdump, da eventuell andere Aliases verwendet werden.

Satyria: Die Seite wurde neu angelegt: „== Aliase == -> Verwendung von Aliase, um den Code besser zu verstehen, Problem beim debuggen, objdump, da eventuell andere Aliases verwendet werden. Die von dir beobachtete Diskrepanz resultiert aus dem Unterschied zwischen der Assembly-Syntax und der tatsächlichen Maschinencodierung sowie der Art und Weise, wie `objdump` und der Assembler die Befehle interpretieren. Lass uns das Schritt für Schritt erklären: --- ### **1. ARM64-Befehlsalias…“

2025-04-08T06:47:28Z

Die Seite wurde neu angelegt: „== Aliase == -> Verwendung von Aliase, um den Code besser zu verstehen, Problem beim debuggen, objdump, da eventuell andere Aliases verwendet werden. Die von dir beobachtete Diskrepanz resultiert aus dem Unterschied zwischen der **Assembly-Syntax** und der tatsächlichen **Maschinencodierung** sowie der Art und Weise, wie `objdump` und der Assembler die Befehle interpretieren. Lass uns das Schritt für Schritt erklären: --- ### **1. ARM64-Befehlsalias…“

Neue Seite

== Aliase ==
-> Verwendung von Aliase, um den Code besser zu verstehen, Problem beim debuggen, objdump, da eventuell andere Aliases verwendet werden.

Die von dir beobachtete Diskrepanz resultiert aus dem Unterschied zwischen der **Assembly-Syntax** und der tatsächlichen **Maschinencodierung** sowie der Art und Weise, wie `objdump` und der Assembler die Befehle interpretieren. Lass uns das Schritt für Schritt erklären:

---

### **1. ARM64-Befehlsaliasing**
In ARM64 gibt es viele **Aliase**, d. h. alternative Schreibweisen für denselben Maschinenbefehl. Diese Aliase werden oft verwendet, um die Lesbarkeit des Codes zu verbessern. Beispiele:

- **`MOV x0, x1`** ist ein Alias für **`ORR x0, xzr, x1`**.
- Semantik: Kopiere den Inhalt von `x1` nach `x0`.
- Implementierung: Ein logisches OR mit `xzr` (dem Null-Register) ergibt einfach den Wert von `x1`.

- **`ADD x0, xzr, x1`** ist ebenfalls ein Alias für **`ORR x0, xzr, x1`**.
- Semantik: Addiere `x1` zu `xzr` (immer `0`), was effektiv einfach `x1` ist.

---

### **2. Warum wird aus `MOV` oder `ADD` ein `ORR`?**
Die ARM64-Maschinenarchitektur verwendet für mehrere Befehle denselben Opcode. Der tatsächlich verwendete Maschinenbefehl für alle drei (`MOV`, `ADD xzr`, `ORR`) lautet **`ORR`**, da dieser Opcode universell genug ist, um die gewünschten Operationen auszuführen.

Der Assembler interpretiert den Code basierend auf der Absicht des Programmierers:
- **`MOV`**: Ein Alias, wird zu einem `ORR` kompiliert.
- **`ADD xzr`**: Ein Alias für denselben `ORR`.
- **`ORR`**: Der explizite Maschinenbefehl.

---

### **3. Warum zeigt `objdump` wieder `MOV` oder `ADD` an?**
Das Tool `objdump` arbeitet nicht nur auf Maschinencode-Ebene, sondern versucht, den Assembly-Code durch **Rückübersetzung** lesbar zu machen. Dabei:
- Entscheidet es sich für die **verständlichste Darstellung**, basierend auf dem Kontext und den Aliases.
- Wenn es sieht, dass der Maschinenbefehl einem Alias entspricht (z. B. `ORR x0, xzr, x1`), gibt es ihn möglicherweise als `MOV x0, x1` oder `ADD x0, xzr, x1` zurück.

In deinem Fall:
1. Der Assembler hat den Alias `MOV x0, x1` in den Maschinenbefehl `ORR x0, xzr, x1` kompiliert.
2. `objdump` hat diesen Maschinenbefehl rückübersetzt und **den Alias gewählt, der am besten passt**.
- Hier hat es sich wieder für `MOV x0, x1` oder `ADD x0, xzr, x1` entschieden, obwohl der zugrunde liegende Befehl tatsächlich `ORR` ist.

---

### **4. Warum nicht immer `ORR`?**
Tools wie `objdump` bevorzugen eine lesbare Darstellung:
- **`MOV`** ist für Menschen intuitiver als `ORR xzr`.
- Der Assembler und Disassembler abstrahieren unnötige Details, um den Code einfacher zu machen.

---

### **Zusammenfassung**
Dein Verständnis ist korrekt: Alle drei Befehle (`MOV`, `ADD xzr`, `ORR`) sind **funktional identisch**. `objdump` wählt jedoch je nach Kontext einen Alias aus, der die Intention des Originalcodes besser widerspiegelt.

Es gibt also keinen Fehler in deiner Beobachtung. Wenn du immer den zugrunde liegenden Maschinenbefehl sehen möchtest, kannst du die Binärdatei mit einem Hex-Editor oder Disassembler auf Opcode-Ebene analysieren. Dort siehst du, dass alle drei als `ORR` codiert sind.

← Nächstältere Version		Version vom 11. April 2025, 06:36 Uhr
Zeile 59:		Zeile 59:
	== Bekannte Aliase im ARM64-Assembler ==		== Bekannte Aliase im ARM64-Assembler ==

	\| Alias \| Entsprechender Instruktionscode \| Beschreibung \|		{\| class="wikitable"
	\|-~~---------------\|------------------------------------------------\|------------------------------------------\|~~		\|-
	\| `mov x0, x1` \| `orr x0, x1, xzr` \| Kopiere Register \|		! Alias !! Entsprechender Instruktionscode !! Beschreibung
	\| `mov x0, #0` \| `movz x0, #0` \| Setze Register auf 0 \|		\|-
	\| `cmp x0, x1` \| `subs xzr, x0, x1` \| Vergleich über Subtraktion ohne Ergebnis \|		\| `mov x0, x1` \|\| `orr x0, x1, xzr` \|\| Kopiere Register
	\| `neg x0, x1` \| `sub x0, xzr, x1` \| Negation \|		\|-
	\| `nop` \| `hint #0` \| Kein-Operation (für Alignment etc.) \|		\| `mov x0, #0` \|\| `movz x0, #0` \|\| Setze Register auf 0
	\| `ret` \| `br x30` \| Rücksprung aus Funktion \|		\|-
	\| `b label` \| `b label` (kein Alias) \| Unbedingter Sprung \|		\| `cmp x0, x1` \|\| `subs xzr, x0, x1` \|\| Vergleich über Subtraktion ohne Ergebnis
	\| `bl label` \| `bl label` (kein Alias) \| Sprung mit Link (Funktionsaufruf) \|		\|-
	\| `movk/movz/movn`\| Literalladen in 16-Bit-Chunks \| Register initialisieren mit Immediate \|		\| `neg x0, x1` \|\| `sub x0, xzr, x1` \|\| Negation
			\|-
			\| `nop` \|\| `hint #0` \|\| Kein-Operation (für Alignment etc.)
			\|-
			\| `ret` \|\| `br x30` \|\| Rücksprung aus Funktion
			\|-
			\| `b label` \|\| `b label` (kein Alias) \|\| Unbedingter Sprung
			\|-
			\| `bl label` \|\| `bl label` (kein Alias) \|\| Sprung mit Link (Funktionsaufruf)
			\|-
			\| `movk/movz/movn`\|\| Literalladen in 16-Bit-Chunks \|\| Register initialisieren mit Immediate
			\|}

	== Warum ist das wichtig? ==		== Warum ist das wichtig? ==