Quelltext der Seite Strukturen in Assembler

Strukturen (structs) sind in C ein wesentlicher Bestandteil zur Organisation und Gruppierung von Daten. In ARM64-Assembler können Strukturen durch die Offsets der einzelnen Felder simuliert werden. Hier ist eine Erklärung, wie man Strukturen in ARM64-Assembler umsetzt, einschließlich der Handhabung von verschachtelten Strukturen.

== Grundlagen ==
Eine Struktur in C kann in ARM64-Assembler dargestellt werden, indem man die Offsets der einzelnen Mitglieder der Struktur manuell verwaltet. Dies erfordert eine genaue Kenntnis der Byte-Offsets, um auf die richtigen Daten zuzugreifen.

== Beispiel: Einfache Struktur ==
C-Code:
<syntaxhighlight lang="c">
struct Point {
    int x;
    int y;
};

struct Point p;
p.x = 10;
p.y = 20;
</syntaxhighlight>
ARM64-Assembler:
:1. Definieren der Offsets:
:<syntaxhighlight lang="asm">
.equ POINT_X_OFFSET, 0
.equ POINT_Y_OFFSET, 4
.equ POINT_SIZE, 8
</syntaxhighlight>
:2. Speicher reservieren und Struktur initialisieren:
:<syntaxhighlight lang="asm">
.data
p:  .skip POINT_SIZE  // Platz für Struktur reservieren (8 Bytes)

.text
ldr x0, =p         // Adresse von p in x0 laden
mov w1, #10        // Wert 10 in w1 laden
str w1, [x0, #POINT_X_OFFSET] // p.x = 10
mov w1, #20        // Wert 20 in w1 laden
str w1, [x0, #POINT_Y_OFFSET] // p.y = 20
</syntaxhighlight>
== Beispiel: Verschachtelte Strukturen ==
C-Code:
<syntaxhighlight lang="c">
struct Point {
    int x;
    int y;
};

struct Rectangle {
    struct Point top_left;
    struct Point bottom_right;
};

struct Rectangle rect;
rect.top_left.x = 10;
rect.top_left.y = 20;
rect.bottom_right.x = 30;
rect.bottom_right.y = 40;
</syntaxhighlight>
ARM64-Assembler:
:1. Definieren der Offsets:
:<syntaxhighlight lang="asm">
// Point Struktur
.equ POINT_X_OFFSET, 0
.equ POINT_Y_OFFSET, 4
.equ POINT_SIZE, 8

// Rectangle Struktur
.equ RECT_TL_OFFSET, 0
.equ RECT_BR_OFFSET, POINT_SIZE
.equ RECT_SIZE, 2 * POINT_SIZE
</syntaxhighlight>
:2. Speicher reservieren und Struktur initialisieren:
:<syntaxhighlight lang="asm">
.data
rect: .skip RECT_SIZE  // Platz für Struktur reservieren (16 Bytes)

.text
ldr x0, =rect      // Adresse von rect in x0 laden

// rect.top_left.x = 10
mov w1, #10
str w1, [x0, #RECT_TL_OFFSET + POINT_X_OFFSET]

// rect.top_left.y = 20
mov w1, #20
str w1, [x0, #RECT_TL_OFFSET + POINT_Y_OFFSET]

// rect.bottom_right.x = 30
mov w1, #30
str w1, [x0, #RECT_BR_OFFSET + POINT_X_OFFSET]

// rect.bottom_right.y = 40
mov w1, #40
str w1, [x0, #RECT_BR_OFFSET + POINT_Y_OFFSET]
</syntaxhighlight>
=== Erklärung ===
'''Offset-Definition''':

:'''Direkte Offsets''': Die Offsets der Felder in einer Struktur werden durch konstante Definitionen (.equ) festgelegt.
: '''Verschachtelung''': Offsets verschachtelter Strukturen werden addiert, um den Zugriff auf die inneren Felder zu ermöglichen.

'''Speicherreservierung''':

:<code>.skip <Anzahl Bytes></code> reserviert Speicherplatz in der .data-Sektion für die Struktur.

'''Adress- und Wertzuweisung''':

:'''Laden der Basisadresse''': Die Basisadresse der Struktur wird in ein Register geladen (<code>ldr x0, =rect</code>).
:'''Zuweisung''': Mit <code>str</code> wird der Wert an die berechnete Adresse geschrieben, unter Hinzufügung der relevanten Offsets.

== Tipps ==
'''Alignment''': Achte darauf, dass die Strukturfelder entsprechend ihrer natürlichen Ausrichtung ausgerichtet sind, um mögliche Zugriffsverletzungen zu vermeiden.

'''Dokumentation''': Gute Kommentare und sorgfältige Dokumentation der Offsets und Strukturen erleichtern das Verständnis und die Wartung des Assemblers.

== Verwendung von Makros ==
Makros in Assembler können helfen, den Code lesbarer, wartbarer und generischer zu machen, indem sie häufig wiederkehrende Codefragmente abstrahieren und automatisieren. In der ARM64-Assembler-Sprache können Makros verwendet werden, um die Arbeit mit Strukturen zu erleichtern, insbesondere wenn es komplexere oder verschachtelte Strukturen gibt.

Hier sind einige Beispiele, wie Makros die Arbeit mit Strukturen in ARM64-Assembler vereinfachen können:

=== Beispiel 1: Einfache Struktur mit Makros ===
C-Code:
<syntaxhighlight lang="C">
struct Point {
    int x;
    int y;
};

struct Point p;
p.x = 10;
p.y = 20;
</syntaxhighlight>
ARM64-Assembler mit Makros:
:Makro-Definitionen:
:<syntaxhighlight lang="asm">
.macro INIT_POINT name, x_val, y_val
    ldr x0, =\name
    mov w1, \x_val
    str w1, [x0, #0]          // x offset
    mov w1, \y_val
    str w1, [x0, #4]          // y offset
.endm

.macro SET_POINT_X name, x_val
    ldr x0, =\name
    mov w1, \x_val
    str w1, [x0, #0]          // x offset
.endm

.macro SET_POINT_Y name, y_val
    ldr x0, =\name
    mov w1, \y_val
    str w1, [x0, #4]          // y offset
.endm
</syntaxhighlight>
:Verwendung der Makros:
:<syntaxhighlight lang="asm">
.data
p:  .skip 8  // Platz für Struktur reservieren (8 Bytes)

.text
INIT_POINT p, 10, 20
</syntaxhighlight>
=== Beispiel 2: Verschachtelte Strukturen mit Makros ===
C-Code:
<syntaxhighlight lang="C">
struct Point {
    int x;
    int y;
};

struct Rectangle {
    struct Point top_left;
    struct Point bottom_right;
};

struct Rectangle rect;
rect.top_left.x = 10;
rect.top_left.y = 20;
rect.bottom_right.x = 30;
rect.bottom_right.y = 40;
</syntaxhighlight>
ARM64-Assembler mit Makros:
:Makro-Definitionen:
:<syntaxhighlight lang="asm">
.macro INIT_RECTANGLE name, tlx, tly, brx, bry
    ldr x0, =\name
    mov w1, \tlx
    str w1, [x0, #0]          // top_left.x offset
    mov w1, \tly
    str w1, [x0, #4]          // top_left.y offset
    mov w1, \brx
    str w1, [x0, #8]          // bottom_right.x offset
    mov w1, \bry
    str w1, [x0, #12]         // bottom_right.y offset
.endm

.macro SET_RECT_TL_X name, tlx
    ldr x0, =\name
    mov w1, \tlx
    str w1, [x0, #0]          // top_left.x offset
.endm

.macro SET_RECT_TL_Y name, tly
    ldr x0, =\name
    mov w1, \tly
    str w1, [x0, #4]          // top_left.y offset
.endm

.macro SET_RECT_BR_X name, brx
    ldr x0, =\name
    mov w1, \brx
    str w1, [x0, #8]          // bottom_right.x offset
.endm

.macro SET_RECT_BR_Y name, bry
    ldr x0, =\name
    mov w1, \bry
    str w1, [x0, #12]         // bottom_right.y offset
.endm
</syntaxhighlight>
:Verwendung der Makros:
:<syntaxhighlight lang="asm">
.data
rect: .skip 16  // Platz für Struktur reservieren (16 Bytes)

.text
INIT_RECTANGLE rect, 10, 20, 30, 40
</syntaxhighlight>
=== Erklärung der Makros ===
'''Makro-Definitionen''':

<code>.macro</code> definiert ein Makro. In den runden Klammern folgen die Parameter, die dem Makro bei der Verwendung übergeben werden.

<code>ldr x0, =\name</code> lädt die Adresse der Struktur in Register <code>x0</code>.

<code>mov w1, \x_val</code> lädt den Wert des x-Feldes in Register <code>w1</code>.

<code>str w1, [x0, #0]</code> speichert den Wert aus <code>w1</code> an der durch <code>x0</code> und Offset bestimmten Adresse.

''Verwendung der Makros'':

Du rufst das Makro auf, indem du seinen Namen und die notwendigen Parameter angibst, z.B. <code>INIT_POINT p, 10, 20</code>.

Dies verbessert die Lesbarkeit und Wartung des Codes, da du häufiger wiederkehrenden Code zentral an einer Stelle definieren und einfach aufrufen kannst.

Makros sind somit eine mächtige Methode, um wiederholten Code zu reduzieren und sicherzustellen, dass komplexe Aufgaben konsistent durchgeführt werden.