Multiplizieren, Dividieren und Akkumulation - Versionsgeschichte

Satyria: /* Akkumulation */

2024-11-28T13:15:46Z

Akkumulation

← Nächstältere Version		Version vom 28. November 2024, 14:15 Uhr
Zeile 174:		Zeile 174:
	In ARM64-Assembler gibt es spezielle Befehle, die die Akkumulation unterstützen. Dies ermöglicht es, Multiplikationsoperationen mit einer zusätzlichen Additions- oder Subtraktionsoperation zu kombinieren. Diese Befehle sind besonders nützlich für komplexere arithmetische Berechnungen und Optimierungen.		In ARM64-Assembler gibt es spezielle Befehle, die die Akkumulation unterstützen. Dies ermöglicht es, Multiplikationsoperationen mit einer zusätzlichen Additions- oder Subtraktionsoperation zu kombinieren. Diese Befehle sind besonders nützlich für komplexere arithmetische Berechnungen und Optimierungen.

	Akkumulierende Multiplikation: <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>		=== Akkumulierende Multiplikation: <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight> ===
	Die Befehle <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> (multiply-accumulate) und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight> (multiply-subtract) bilden die Grundlage für akkumulative Operationen bei der Multiplikation.		Die Befehle <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> (multiply-accumulate) und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight> (multiply-subtract) bilden die Grundlage für akkumulative Operationen bei der Multiplikation.

	Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl		=== Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl ===
	Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl multipliziert zwei Register und addiert das Ergebnis zu einem dritten Register.		Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl multipliziert zwei Register und addiert das Ergebnis zu einem dritten Register.

Zeile 199:		Zeile 199:
	In diesem Beispiel:		In diesem Beispiel:

	x0 * x1 ergibt 6.		'''x0''' * '''x1''' ergibt 6.
	Dann wird 6 zu x2 (4) addiert, um das endgültige Ergebnis 10 in x3 zu speichern.		Dann wird 6 zu '''x2''' (4) addiert, um das endgültige Ergebnis 10 in '''x3''' zu speichern.
	Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl		=== Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl ===
	Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl multipliziert zwei Register und subtrahiert das Ergebnis von einem dritten Register.		Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl multipliziert zwei Register und subtrahiert das Ergebnis von einem dritten Register.

Zeile 223:		Zeile 223:
	In diesem Beispiel:		In diesem Beispiel:

	x0 * x1 ergibt 15.		'''x0''' * '''x1''' ergibt 15.
	Dann wird 15 von x2 (20) subtrahiert, um das endgültige Ergebnis 5 in x3 zu speichern.		Dann wird 15 von '''x2''' (20) subtrahiert, um das endgültige Ergebnis 5 in '''x3''' zu speichern.

Satyria am 28. November 2024 um 13:12 Uhr

2024-11-28T13:12:22Z

← Nächstältere Version		Version vom 28. November 2024, 14:12 Uhr
Zeile 174:		Zeile 174:
	In ARM64-Assembler gibt es spezielle Befehle, die die Akkumulation unterstützen. Dies ermöglicht es, Multiplikationsoperationen mit einer zusätzlichen Additions- oder Subtraktionsoperation zu kombinieren. Diese Befehle sind besonders nützlich für komplexere arithmetische Berechnungen und Optimierungen.		In ARM64-Assembler gibt es spezielle Befehle, die die Akkumulation unterstützen. Dies ermöglicht es, Multiplikationsoperationen mit einer zusätzlichen Additions- oder Subtraktionsoperation zu kombinieren. Diese Befehle sind besonders nützlich für komplexere arithmetische Berechnungen und Optimierungen.

	Akkumulierende Multiplikation: mla und mls		Akkumulierende Multiplikation: <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>
	Die Befehle mla (multiply-accumulate) und mls (multiply-subtract) bilden die Grundlage für akkumulative Operationen bei der Multiplikation.		Die Befehle <syntaxhighlight lang="asm" inline>mla</syntaxhighlight> (multiply-accumulate) und <syntaxhighlight lang="asm" inline>mls</syntaxhighlight> (multiply-subtract) bilden die Grundlage für akkumulative Operationen bei der Multiplikation.

	Der mla-Befehl		Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl
	Der mla-Befehl multipliziert zwei Register und addiert das Ergebnis zu einem dritten Register.		Der <syntaxhighlight lang="asm" inline>mla</syntaxhighlight>-Befehl multipliziert zwei Register und addiert das Ergebnis zu einem dritten Register.

	Syntax:		Syntax:
	mla <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister>		<syntaxhighlight lang="asm" inline>mla <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister></syntaxhighlight>

	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 194:		Zeile 196:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	In diesem Beispiel:		In diesem Beispiel:

	x0 * x1 ergibt 6.		x0 * x1 ergibt 6.
	Dann wird 6 zu x2 (4) addiert, um das endgültige Ergebnis 10 in x3 zu speichern.		Dann wird 6 zu x2 (4) addiert, um das endgültige Ergebnis 10 in x3 zu speichern.
	Der mls-Befehl		Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl
	Der mls-Befehl multipliziert zwei Register und subtrahiert das Ergebnis von einem dritten Register.		Der <syntaxhighlight lang="asm" inline>mls</syntaxhighlight>-Befehl multipliziert zwei Register und subtrahiert das Ergebnis von einem dritten Register.

	Syntax:		Syntax:
	mls <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister>		<syntaxhighlight lang="asm" inline>mls <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister></syntaxhighlight>

	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 215:		Zeile 220:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	In diesem Beispiel:		In diesem Beispiel:

	x0 * x1 ergibt 15.		x0 * x1 ergibt 15.
	Dann wird 15 von x2 (20) subtrahiert, um das endgültige Ergebnis 5 in x3 zu speichern.		Dann wird 15 von x2 (20) subtrahiert, um das endgültige Ergebnis 5 in x3 zu speichern.

Satyria am 28. November 2024 um 13:08 Uhr

2024-11-28T13:08:50Z

← Nächstältere Version		Version vom 28. November 2024, 14:08 Uhr
Zeile 170:		Zeile 170:
	svc 0 // system call		svc 0 // system call
	</syntaxhighlight>		</syntaxhighlight>

			== Akkumulation ==
			In ARM64-Assembler gibt es spezielle Befehle, die die Akkumulation unterstützen. Dies ermöglicht es, Multiplikationsoperationen mit einer zusätzlichen Additions- oder Subtraktionsoperation zu kombinieren. Diese Befehle sind besonders nützlich für komplexere arithmetische Berechnungen und Optimierungen.

			Akkumulierende Multiplikation: mla und mls
			Die Befehle mla (multiply-accumulate) und mls (multiply-subtract) bilden die Grundlage für akkumulative Operationen bei der Multiplikation.

			Der mla-Befehl
			Der mla-Befehl multipliziert zwei Register und addiert das Ergebnis zu einem dritten Register.

			Syntax:
			mla <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister>
			Beispiel:
			.global _start

			_start:
			mov x0, #2 // Setze x0 auf 2
			mov x1, #3 // Setze x1 auf 3
			mov x2, #4 // Setze x2 auf 4
			mla x3, x0, x1, x2 // x3 = (x0 * x1) + x2 = (2 * 3) + 4 = 10

			// Programm beenden
			mov x8, #93 // exit system call
			svc 0 // system call
			In diesem Beispiel:

			x0 * x1 ergibt 6.
			Dann wird 6 zu x2 (4) addiert, um das endgültige Ergebnis 10 in x3 zu speichern.
			Der mls-Befehl
			Der mls-Befehl multipliziert zwei Register und subtrahiert das Ergebnis von einem dritten Register.

			Syntax:
			mls <Zielregister>, <Quellregister1>, <Quellregister2>, <Akkumulationsregister>
			Beispiel:
			.global _start

			_start:
			mov x0, #5 // Setze x0 auf 5
			mov x1, #3 // Setze x1 auf 3
			mov x2, #20 // Setze x2 auf 20
			mls x3, x0, x1, x2 // x3 = x2 - (x0 * x1) = 20 - (5 * 3) = 20 - 15 = 5

			// Programm beenden
			mov x8, #93 // exit system call
			svc 0 // system call
			In diesem Beispiel:

			x0 * x1 ergibt 15.
			Dann wird 15 von x2 (20) subtrahiert, um das endgültige Ergebnis 5 in x3 zu speichern.

Satyria: /* Division einer 128-Bit-Zahl: udiv verwenden */

2024-11-28T13:00:11Z

Division einer 128-Bit-Zahl: udiv verwenden

← Nächstältere Version		Version vom 28. November 2024, 14:00 Uhr
Zeile 141:		Zeile 141:
	Beispiel für Division einer 128-Bit-Zahl durch eine 64-Bit-Zahl:		Beispiel für Division einer 128-Bit-Zahl durch eine 64-Bit-Zahl:

	Angenommen, wir haben eine 128-Bit-Zahl in den Registern x0 (untere 64-Bit) und x1 (obere 64-Bit) und wir wollen durch die 64-Bit-Zahl in x2 dividieren.		Angenommen, wir haben eine 128-Bit-Zahl in den Registern '''x0''' (untere 64-Bit) und '''x1''' (obere 64-Bit) und wir wollen durch die 64-Bit-Zahl in '''x2''' dividieren.

	# Konvertiere die obere 64-Bit-Zahl zu einer 128-Bit-Zahl.		# Konvertiere die obere 64-Bit-Zahl zu einer 128-Bit-Zahl.

Satyria: /* Umgang mit Überlauf bei 64-Bit-Multiplikation */

2024-11-28T12:58:53Z

Umgang mit Überlauf bei 64-Bit-Multiplikation

← Nächstältere Version		Version vom 28. November 2024, 13:58 Uhr
Zeile 55:		Zeile 55:
	svc 0 // system call		svc 0 // system call
	</syntaxhighlight>		</syntaxhighlight>
	In diesem Fall ist die erwartete 128-Bit-Zahl 0x1FFFFFFFFFFFFFFFE, aber x2 enthält nur 0xFFFFFFFFFFFFFFFE, also die unteren 64 Bits des Ergebnisses.		In diesem Fall ist die erwartete 128-Bit-Zahl 0x1FFFFFFFFFFFFFFFE, aber '''x2''' enthält nur 0xFFFFFFFFFFFFFFFE, also die unteren 64 Bits des Ergebnisses.

	=== Lösung mit umulh zum Feststellen des Überlaufs ===		=== Lösung mit umulh zum Feststellen des Überlaufs ===
Zeile 88:		Zeile 88:
	Erklärung der Schritte:		Erklärung der Schritte:

	Setze x0 und x1: Wir setzen zwei große Werte in die Register x0 und x1.		Setze '''x0''' und '''x1''': Wir setzen zwei große Werte in die Register '''x0''' und '''x1'''.

	Multipliziere und speichere die unteren 64-Bits:		Multipliziere und speichere die unteren 64-Bits:

	<syntaxhighlight lang="asm" inline>mul x2, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert das Ergebnis in x2. Dies speichert die unteren 64 Bits des Produkts.		<syntaxhighlight lang="asm" inline>mul x2, x0, x1</syntaxhighlight>: Multipliziert '''x0''' und '''x1''' und speichert das Ergebnis in '''x2'''. Dies speichert die unteren 64 Bits des Produkts.

	Multipliziere und speichere die oberen 64-Bits:		Multipliziere und speichere die oberen 64-Bits:

	<syntaxhighlight lang="asm" inline>umulh x3, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert die oberen 64 Bits des Produkts in x3.		<syntaxhighlight lang="asm" inline>umulh x3, x0, x1</syntaxhighlight>: Multipliziert '''x0''' und '''x1''' und speichert die oberen 64 Bits des Produkts in '''x3'''.

	Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register x2 (untere 64 Bits) und x3 (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.		Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register '''x2''' (untere 64 Bits) und '''x3''' (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.

	== Division: udiv-Befehl ==		== Division: udiv-Befehl ==

Satyria: /* Division einer 128-Bit-Zahl: udiv verwenden */

2024-11-28T12:52:22Z

Division einer 128-Bit-Zahl: udiv verwenden

← Nächstältere Version		Version vom 28. November 2024, 13:52 Uhr
Zeile 140:		Zeile 140:

	Beispiel für Division einer 128-Bit-Zahl durch eine 64-Bit-Zahl:		Beispiel für Division einer 128-Bit-Zahl durch eine 64-Bit-Zahl:

	Angenommen, wir haben eine 128-Bit-Zahl in den Registern x0 (untere 64-Bit) und x1 (obere 64-Bit) und wir wollen durch die 64-Bit-Zahl in x2 dividieren.		Angenommen, wir haben eine 128-Bit-Zahl in den Registern x0 (untere 64-Bit) und x1 (obere 64-Bit) und wir wollen durch die 64-Bit-Zahl in x2 dividieren.

	Konvertiere die obere 64-Bit-Zahl zu einer 128-Bit-Zahl.		# Konvertiere die obere 64-Bit-Zahl zu einer 128-Bit-Zahl.
	Füge die untere 64-Bit-Zahl dazu.		# Füge die untere 64-Bit-Zahl dazu.
	Teile alles durch die 64-Bit-Zahl.		# Teile alles durch die 64-Bit-Zahl.
	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
	.global _start		.global _start

Satyria: /* Division: udiv-Befehl */

2024-11-28T12:51:13Z

Division: udiv-Befehl

← Nächstältere Version		Version vom 28. November 2024, 13:51 Uhr
Zeile 105:		Zeile 105:
	Syntax:		Syntax:
	<syntaxhighlight lang="asm" inline>udiv <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>		<syntaxhighlight lang="asm" inline>udiv <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>

	Beispiel:		Beispiel:
	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
Zeile 118:		Zeile 119:
	svc 0 // system call		svc 0 // system call
	</syntaxhighlight>		</syntaxhighlight>

	== Umgang mit negativen Zahlen bei der Division ==		== Umgang mit negativen Zahlen bei der Division ==
	Bei der Division von vorzeichenbehafteten Zahlen verwenden wir <syntaxhighlight lang="asm" inline>sdiv</syntaxhighlight> (signed divide).		Bei der Division von vorzeichenbehafteten Zahlen verwenden wir <syntaxhighlight lang="asm" inline>sdiv</syntaxhighlight> (signed divide).

Satyria: /* Lösung mit umulh zum Feststellen des Überlaufs */

2024-11-28T12:50:21Z

Lösung mit umulh zum Feststellen des Überlaufs

← Nächstältere Version		Version vom 28. November 2024, 13:50 Uhr
Zeile 61:		Zeile 61:

	Gebrauch von <syntaxhighlight lang="asm" inline>mul</syntaxhighlight> und <syntaxhighlight lang="asm" inline>umulh</syntaxhighlight> für 128-Bit-Multiplikation		Gebrauch von <syntaxhighlight lang="asm" inline>mul</syntaxhighlight> und <syntaxhighlight lang="asm" inline>umulh</syntaxhighlight> für 128-Bit-Multiplikation

	<syntaxhighlight lang="asm" inline>mul</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und behält die unteren 64 Bits.		<syntaxhighlight lang="asm" inline>mul</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und behält die unteren 64 Bits.

	<syntaxhighlight lang="asm" inline>umulh</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des Resultats zurück.		<syntaxhighlight lang="asm" inline>umulh</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des Resultats zurück.

	Beispiel:		Beispiel:
	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
Zeile 84:		Zeile 87:
	</syntaxhighlight>		</syntaxhighlight>
	Erklärung der Schritte:		Erklärung der Schritte:

	Setze x0 und x1: Wir setzen zwei große Werte in die Register x0 und x1.		Setze x0 und x1: Wir setzen zwei große Werte in die Register x0 und x1.

	Multipliziere und speichere die unteren 64-Bits:		Multipliziere und speichere die unteren 64-Bits:

	<syntaxhighlight lang="asm" inline>mul x2, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert das Ergebnis in x2. Dies speichert die unteren 64 Bits des Produkts.		<syntaxhighlight lang="asm" inline>mul x2, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert das Ergebnis in x2. Dies speichert die unteren 64 Bits des Produkts.

	Multipliziere und speichere die oberen 64-Bits:		Multipliziere und speichere die oberen 64-Bits:

	<syntaxhighlight lang="asm" inline>umulh x3, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert die oberen 64 Bits des Produkts in x3.		<syntaxhighlight lang="asm" inline>umulh x3, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert die oberen 64 Bits des Produkts in x3.

	Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register x2 (untere 64 Bits) und x3 (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.		Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register x2 (untere 64 Bits) und x3 (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.

Satyria: /* Einfache Multiplikation: mul-Befehl */

2024-11-28T12:48:08Z

Einfache Multiplikation: mul-Befehl

← Nächstältere Version		Version vom 28. November 2024, 13:48 Uhr
Zeile 6:		Zeile 6:
	Syntax:		Syntax:
	<syntaxhighlight lang="asm" inline>mul <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>		<syntaxhighlight lang="asm" inline>mul <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>

	Beispiel:		Beispiel:
	<syntaxhighlight lang="asm">		<syntaxhighlight lang="asm">
Zeile 19:		Zeile 20:
	svc 0 // system call		svc 0 // system call
	</syntaxhighlight>		</syntaxhighlight>

	== Multiplikation und Umgang mit negativen Zahlen ==		== Multiplikation und Umgang mit negativen Zahlen ==
	In ARM64-Assembler sind Zahlen standardmäßig als vorzeichenbehaftet (signed). Der <syntaxhighlight lang="asm" inline>mul</syntaxhighlight>-Befehl funktioniert daher korrekt mit negativen Zahlen.		In ARM64-Assembler sind Zahlen standardmäßig als vorzeichenbehaftet (signed). Der <syntaxhighlight lang="asm" inline>mul</syntaxhighlight>-Befehl funktioniert daher korrekt mit negativen Zahlen.

Satyria am 28. November 2024 um 12:47 Uhr

2024-11-28T12:47:13Z

← Nächstältere Version		Version vom 28. November 2024, 13:47 Uhr
Zeile 5:		Zeile 5:

	Syntax:		Syntax:
	mul <Zielregister>, <Quellregister1>, <Quellregister2>		<syntaxhighlight lang="asm" inline>mul <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>
	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 17:		Zeile 18:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	== Multiplikation und Umgang mit negativen Zahlen ==		== Multiplikation und Umgang mit negativen Zahlen ==
	In ARM64-Assembler sind Zahlen standardmäßig als vorzeichenbehaftet (signed). Der mul-Befehl funktioniert daher korrekt mit negativen Zahlen.		In ARM64-Assembler sind Zahlen standardmäßig als vorzeichenbehaftet (signed). Der <syntaxhighlight lang="asm" inline>mul</syntaxhighlight>-Befehl funktioniert daher korrekt mit negativen Zahlen.

	Beispiel mit negativen Zahlen:		Beispiel mit negativen Zahlen:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 31:		Zeile 34:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>

	== Umgang mit Überlauf bei 64-Bit-Multiplikation ==		== Umgang mit Überlauf bei 64-Bit-Multiplikation ==
	Das mul-Kommando in ARM64-Assembler multipliziert zwei 64-Bit-Register und speichert das Ergebnis in einem einzigen 64-Bit-Register. Problematisch wird es, wenn das Resultat größer als 64 Bit wird, da mul das Ergebnis auf die unteren 64 Bit beschränkt und keine Information über einen möglichen Überlauf bereitstellt.		Das <syntaxhighlight lang="asm" inline>mul</syntaxhighlight>-Kommando in ARM64-Assembler multipliziert zwei 64-Bit-Register und speichert das Ergebnis in einem einzigen 64-Bit-Register. Problematisch wird es, wenn das Resultat größer als 64 Bit wird, da <syntaxhighlight lang="asm" inline>mul</syntaxhighlight> das Ergebnis auf die unteren 64 Bit beschränkt und keine Information über einen möglichen Überlauf bereitstellt.

	=== Beispiel für das Problem ===		=== Beispiel für das Problem ===
	Angenommen, wir multiplizieren zwei große 64-Bit-Zahlen, deren Produkt mehr als 64 Bit umfasst:		Angenommen, wir multiplizieren zwei große 64-Bit-Zahlen, deren Produkt mehr als 64 Bit umfasst:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 49:		Zeile 52:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	In diesem Fall ist die erwartete 128-Bit-Zahl 0x1FFFFFFFFFFFFFFFE, aber x2 enthält nur 0xFFFFFFFFFFFFFFFE, also die unteren 64 Bits des Ergebnisses.		In diesem Fall ist die erwartete 128-Bit-Zahl 0x1FFFFFFFFFFFFFFFE, aber x2 enthält nur 0xFFFFFFFFFFFFFFFE, also die unteren 64 Bits des Ergebnisses.

	=== Lösung mit umulh zum Feststellen des Überlaufs ===		=== Lösung mit umulh zum Feststellen des Überlaufs ===
	Um sicherzustellen, dass das Ergebnis der Multiplikation korrekt und vollständig ist, können wir den Befehl umulh (unsigned multiply high) verwenden. Dieser Befehl multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des 128-Bit-Resultats zurück.		Um sicherzustellen, dass das Ergebnis der Multiplikation korrekt und vollständig ist, können wir den Befehl <syntaxhighlight lang="asm" inline>umulh</syntaxhighlight> (unsigned multiply high) verwenden. Dieser Befehl multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des 128-Bit-Resultats zurück.

	Gebrauch von mul und umulh für 128-Bit-Multiplikation		Gebrauch von <syntaxhighlight lang="asm" inline>mul</syntaxhighlight> und <syntaxhighlight lang="asm" inline>umulh</syntaxhighlight> für 128-Bit-Multiplikation
	mul: Multipliziert zwei 64-Bit-Zahlen und behält die unteren 64 Bits.		<syntaxhighlight lang="asm" inline>mul</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und behält die unteren 64 Bits.
	umulh: Multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des Resultats zurück.		<syntaxhighlight lang="asm" inline>umulh</syntaxhighlight>: Multipliziert zwei 64-Bit-Zahlen und gibt die oberen 64 Bits des Resultats zurück.
	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 76:		Zeile 80:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	Erklärung der Schritte:		Erklärung der Schritte:
	Setze x0 und x1: Wir setzen zwei große Werte in die Register x0 und x1.		Setze x0 und x1: Wir setzen zwei große Werte in die Register x0 und x1.
	Multipliziere und speichere die unteren 64-Bits:		Multipliziere und speichere die unteren 64-Bits:
	mul x2, x0, x1: Multipliziert x0 und x1 und speichert das Ergebnis in x2. Dies speichert die unteren 64 Bits des Produkts.		<syntaxhighlight lang="asm" inline>mul x2, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert das Ergebnis in x2. Dies speichert die unteren 64 Bits des Produkts.
	Multipliziere und speichere die oberen 64-Bits:		Multipliziere und speichere die oberen 64-Bits:
	umulh x3, x0, x1: Multipliziert x0 und x1 und speichert die oberen 64 Bits des Produkts in x3.		<syntaxhighlight lang="asm" inline>umulh x3, x0, x1</syntaxhighlight>: Multipliziert x0 und x1 und speichert die oberen 64 Bits des Produkts in x3.
	Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register x2 (untere 64 Bits) und x3 (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.		Nun haben wir das vollständige 128-Bit-Ergebnis verteilt auf die Register x2 (untere 64 Bits) und x3 (obere 64 Bits). Auf diese Weise können wir sicherstellen, dass das gesamte Produkt genau erfasst wird.

	== Division: udiv-Befehl ==		== Division: udiv-Befehl ==
	Der udiv-Befehl wird verwendet, um zwei 64-Bit-Zahlen zu dividieren.		Der <syntaxhighlight lang="asm" inline>udiv</syntaxhighlight>-Befehl wird verwendet, um zwei 64-Bit-Zahlen zu dividieren.

	Syntax:		Syntax:
	udiv <Zielregister>, <Quellregister1>, <Quellregister2>		<syntaxhighlight lang="asm" inline>udiv <Zielregister>, <Quellregister1>, <Quellregister2></syntaxhighlight>
	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 100:		Zeile 106:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	== Umgang mit negativen Zahlen bei der Division ==		== Umgang mit negativen Zahlen bei der Division ==
	Bei der Division von vorzeichenbehafteten Zahlen verwenden wir sdiv (signed divide).		Bei der Division von vorzeichenbehafteten Zahlen verwenden wir <syntaxhighlight lang="asm" inline>sdiv</syntaxhighlight> (signed divide).

	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 114:		Zeile 122:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>
	== Division einer 128-Bit-Zahl: udiv verwenden ==		== Division einer 128-Bit-Zahl: udiv verwenden ==
	Um eine 128-Bit-Zahl zu dividieren, die in zwei 64-Bit-Registern gespeichert ist, müssen wir die 64-Bit-Teile nacheinander verarbeiten. Dies ist komplexer und erfordert mehrere Schritte, um die Genauigkeit zu gewährleisten.		Um eine 128-Bit-Zahl zu dividieren, die in zwei 64-Bit-Registern gespeichert ist, müssen wir die 64-Bit-Teile nacheinander verarbeiten. Dies ist komplexer und erfordert mehrere Schritte, um die Genauigkeit zu gewährleisten.
Zeile 123:		Zeile 132:
	Füge die untere 64-Bit-Zahl dazu.		Füge die untere 64-Bit-Zahl dazu.
	Teile alles durch die 64-Bit-Zahl.		Teile alles durch die 64-Bit-Zahl.
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 145:		Zeile 155:
	mov x8, #93 // exit system call		mov x8, #93 // exit system call
	svc 0 // system call		svc 0 // system call
			</syntaxhighlight>