Interaktion mit C - Versionsgeschichte

Satyria: /* Inline-Assembler in C */

2025-04-09T10:17:48Z

Inline-Assembler in C

← Nächstältere Version		Version vom 9. April 2025, 11:17 Uhr
Zeile 121:		Zeile 121:
	Um den Teil für __asm__ als reinen ARM64-Assemblercode zu übersetzen, sehen Sie sich folgendes Beispiel an:		Um den Teil für __asm__ als reinen ARM64-Assemblercode zu übersetzen, sehen Sie sich folgendes Beispiel an:

	~~ASM~~		<syntaxhighlight lang="asm">
	~~Copy code~~
	.global add_numbers // Globale Funktion		.global add_numbers // Globale Funktion

Zeile 128:		Zeile 127:
	add w0, w0, w1 // Addiere die Werte in w0 und w1, das Ergebnis wird in w0 gespeichert		add w0, w0, w1 // Addiere die Werte in w0 und w1, das Ergebnis wird in w0 gespeichert
	ret // Rückkehr zur aufrufenden Funktion, wobei das Ergebnis in x0 verbleibt		ret // Rückkehr zur aufrufenden Funktion, wobei das Ergebnis in x0 verbleibt
			</syntaxhighlight>

	In diesem reinen Assemblercode läuft die Funktion add_numbers:		In diesem reinen Assemblercode läuft die Funktion add_numbers:

Satyria: /* Parameter-Erklärung */

2025-04-09T09:05:10Z

Parameter-Erklärung

← Nächstältere Version		Version vom 9. April 2025, 10:05 Uhr
Zeile 108:		Zeile 108:
	=== Parameter-Erklärung ===		=== Parameter-Erklärung ===

	* "add %w0, %w1, %w2": Assembler-Befehl. %w0, %w1, %w2 sind Platzhalter für die entsprechenden Register.		* "add %w0, %w1, %w2": Assembler-Befehl. %w0, %w1, %w2 sind Platzhalter für die entsprechenden Register. Die w-Präfixe zeigen an, dass wir 32-Bit-Werte (int) verwenden.
	* : "=r" (result): Output-Parameter. Das Ergebnis wird in das C-Variable result geschrieben.		* : "=r" (result): Output-Parameter. Das Ergebnis wird in das C-Variable result geschrieben. =r bedeutet, dass der Compiler ein beliebiges Register für das Ergebnis wählen soll, und es ist ein Output-Operanden.
	* : "r" (a), "r" (b): Input-Parameter. Die C-Variablen a und b werden den entsprechenden Platzhaltern zugeordnet.		* : "r" (a), "r" (b): Input-Parameter. Die C-Variablen a und b werden den entsprechenden Platzhaltern zugeordnet. Der Compiler wählt Register, um diese Werte zu speichern.

	'''Wichtige Hinweise:'''		'''Wichtige Hinweise:'''
Zeile 116:		Zeile 116:
	* Inline-Assembler ist architekturspezifisch und sollte mit Bedacht verwendet werden.		* Inline-Assembler ist architekturspezifisch und sollte mit Bedacht verwendet werden.
	* Beachten Sie die korrekte Verwendung und Zuordnung der Register.		* Beachten Sie die korrekte Verwendung und Zuordnung der Register.
			* __asm__ in GNU C ist flexibil und mächtig, aber prüfen Sie, ob optimierende Compiler Ihren Code nicht verändern.

			==== Reiner Assembler ====
			Um den Teil für __asm__ als reinen ARM64-Assemblercode zu übersetzen, sehen Sie sich folgendes Beispiel an:

			ASM
			Copy code
			.global add_numbers // Globale Funktion

			add_numbers:
			add w0, w0, w1 // Addiere die Werte in w0 und w1, das Ergebnis wird in w0 gespeichert
			ret // Rückkehr zur aufrufenden Funktion, wobei das Ergebnis in x0 verbleibt
			In diesem reinen Assemblercode läuft die Funktion add_numbers:

			Die Funktion verwendet die Register w0 und w1 als Eingaben, gemäß dem ARM64-Aufrufkonventionen, wo das erste Argument in w0 und das zweite Argument in w1 übergeben wird.
			Der Befehl add w0, w0, w1 führt die Addition durch und speichert das Ergebnis in w0.
			ret kehrt zur aufrufenden Funktion zurück, wobei w0 (d.h. x0 für 64-Bit) das Ergebnis enthält.

	== Bibliotheken verwenden ==		== Bibliotheken verwenden ==

Satyria am 7. April 2025 um 10:40 Uhr

2025-04-07T10:40:40Z

← Nächstältere Version		Version vom 7. April 2025, 11:40 Uhr
Zeile 1:		Zeile 1:
	In diesem Kapitel werden wir die Integration von ARM64-Bit-Assembler und C-Programmen beleuchten. Die folgenden Themen werden behandelt:		In diesem Kapitel werden wir die Integration von ARM64-Bit-Assembler und C-Programmen beleuchten. Die folgenden Themen werden behandelt:

	* C-Funktionen aus Assembler aufrufen
	* Assemblerfunktionen in C aufrufen
	* Inline-Assembler in C
	* Bibliotheken verwenden
	* C-Funktionen aus Assembler aufrufen

	== C-Funktionen aus Assembler aufrufen ==		== C-Funktionen aus Assembler aufrufen ==

Satyria: Die Seite wurde neu angelegt: „In diesem Kapitel werden wir die Integration von ARM64-Bit-Assembler und C-Programmen beleuchten. Die folgenden Themen werden behandelt: * C-Funktionen aus Assembler aufrufen * Assemblerfunktionen in C aufrufen * Inline-Assembler in C * Bibliotheken verwenden * C-Funktionen aus Assembler aufrufen == C-Funktionen aus Assembler aufrufen == Um C-Funktionen aus Assembler heraus aufzurufen, müssen Sie die folgenden Schritte beachten: * Deklaration der C-F…“

2025-04-07T10:39:25Z

Die Seite wurde neu angelegt: „In diesem Kapitel werden wir die Integration von ARM64-Bit-Assembler und C-Programmen beleuchten. Die folgenden Themen werden behandelt: * C-Funktionen aus Assembler aufrufen * Assemblerfunktionen in C aufrufen * Inline-Assembler in C * Bibliotheken verwenden * C-Funktionen aus Assembler aufrufen == C-Funktionen aus Assembler aufrufen == Um C-Funktionen aus Assembler heraus aufzurufen, müssen Sie die folgenden Schritte beachten: * Deklaration der C-F…“

Neue Seite

In diesem Kapitel werden wir die Integration von ARM64-Bit-Assembler und C-Programmen beleuchten. Die folgenden Themen werden behandelt:

* C-Funktionen aus Assembler aufrufen
* Assemblerfunktionen in C aufrufen
* Inline-Assembler in C
* Bibliotheken verwenden
* C-Funktionen aus Assembler aufrufen

== C-Funktionen aus Assembler aufrufen ==

Um C-Funktionen aus Assembler heraus aufzurufen, müssen Sie die folgenden Schritte beachten:

* Deklaration der C-Funktion in Assembler
* Aufruf der Funktion
* AAPCS (ARM Architecture Procedure Call Standard) beachten

Beispiel in C:
<syntaxhighlight lang="C">
// myfunctions.c
#include <stdio.h>

void my_function(int x) {
printf("The value is: %d\n", x);
}
</syntaxhighlight>

Beispiel in Assembler:
<syntaxhighlight lang="asm">
.extern my_function // Extern deklarierte Funktion

.global _start

_start:
mov x0, #42 // Parameter für die Funktion (Wert: 42)
bl my_function // Aufruf der C-Funktion

// Exit system call
mov x8, #93 // syscall number for exit
mov x0, #0 // exit code
svc 0
</syntaxhighlight>

'''Wichtige Hinweise:'''

* Die C-Funktion muss mit .extern deklariert werden, um den Linker zu informieren.
* Die Parameter müssen gemäß den AAPCS-Regeln in die entsprechenden Register geladen werden (x0 bis x7).
* Der Rückgabewert der Funktion wird in x0 zurückgegeben.
== Assemblerfunktionen in C aufrufen ==

Wenn Sie Assemblerfunktionen in C aufrufen möchten, müssen Sie sie korrekt definieren und deklarieren, um sicherzustellen, dass der C-Compiler und der Linker sie finden und korrekt aufrufen können.

Beispiel in Assembler:
<syntaxhighlight lang="asm">
// myfunctions.s
.global add_numbers

add_numbers:
add x0, x0, x1 // Addiere x0 und x1, Ergebnis in x0
ret // Rückkehr zur aufrufenden Funktion
</syntaxhighlight>

Beispiel in C:
<syntaxhighlight lang="C">
// main.c
#include <stdio.h>

extern int add_numbers(int a, int b); // Deklaration der Assemblerfunktion

int main() {
int result = add_numbers(5, 7);
printf("Result: %d\n", result);
return 0;
}
</syntaxhighlight>

Kompilierung und Linken:
<syntaxhighlight lang="shell">
gcc -c main.c
as -o myfunctions.o myfunctions.s
gcc -o myprogram main.o myfunctions.o
</syntaxhighlight>

'''Wichtige Hinweise:'''

* Die Assemblerfunktion muss mit .global deklariert werden.
* In der C-Datei muss die Assemblerfunktion als extern deklariert werden.
* Parameter und Rückgabewerte müssen gemäß den AAPCS-Konventionen übergeben werden.
== Inline-Assembler in C ==

Inline-Assembler ermöglicht die Einbettung von Assembler-Code direkt in C-Programme, um bestimmte Leistungsoptimierungen oder spezielle Hardwarezugriffe zu ermöglichen.

Beispiel:
<syntaxhighlight lang="C">
#include <stdio.h>

int add_numbers(int a, int b) {
int result;
__asm__ (
"add %w0, %w1, %w2"
: "=r" (result)
: "r" (a), "r" (b)
);
return result;
}

int main() {
int result = add_numbers(5, 7);
printf("Result: %d\n", result);
return 0;
}
</syntaxhighlight>

=== Parameter-Erklärung ===

* "add %w0, %w1, %w2": Assembler-Befehl. %w0, %w1, %w2 sind Platzhalter für die entsprechenden Register.
* : "=r" (result): Output-Parameter. Das Ergebnis wird in das C-Variable result geschrieben.
* : "r" (a), "r" (b): Input-Parameter. Die C-Variablen a und b werden den entsprechenden Platzhaltern zugeordnet.

'''Wichtige Hinweise:'''

* Inline-Assembler ist architekturspezifisch und sollte mit Bedacht verwendet werden.
* Beachten Sie die korrekte Verwendung und Zuordnung der Register.
== Bibliotheken verwenden ==

Um C-Bibliotheken in ARM64-Assembler zu verwenden, müssen Sie sicherstellen, dass die Bibliotheken korrekt eingebunden und die entsprechenden Funktionen extern deklariert werden.

Beispiel: Verwendung der math.h-Bibliothek:

Beispiel in C:
<syntaxhighlight lang="C">
// mymath.c
#include <math.h>

double sqrt_wrapper(double x) {
return sqrt(x);
}
</syntaxhighlight>

Beispiel in Assembler:
<syntaxhighlight lang="asm">
.extern sqrt_wrapper

.global _start

_start:
ldr x0, =9.0 // Lade 9.0 in x0
bl sqrt_wrapper // Rufe sqrt_wrapper auf

// Exit system call
mov x8, #93 // syscall number for exit
mov x0, #0 // exit code
svc 0
</syntaxhighlight>

Kompilierung und Linken:
<syntaxhighlight lang="shell">
gcc -c mymath.c
as -o myprogram.o myprogram.s
gcc -o myprogram myprogram.o mymath.o -lm
</syntaxhighlight>

'''Wichtige Hinweise:'''

Deklarieren Sie alle externen Funktionen, die Sie verwenden möchten.
Stellen Sie sicher, dass die Bibliotheken korrekt beim Linken einbezogen werden (-lm beispielsweise für die Math-Bibliothek).