Deutscher Assembler-Crashkurs

  • Autor: Frabbing

    Kleines Assembler-ABC (MASM32 oder JWASM, 32 Bit).
    Kurs

    Das hier soll keine komplette Anleitung sein, um Assembler zu erlernen. Aber es sollte einem Programmierer, der einen Basic-ähnlichen-Dialekt verstehen kann gestatten, erste Assemblerprogrämmchen zu erstellen.

    Zunächst einmal: Für MASM32-Assembler benötigt man für den Anfang nicht mal keine große Anzahl von Befehlen. Mit 10 Befehlen (insgesamt gibt es über 90) ist man erstmal schon gut bedient, alles andere ist zunächst unnütz, weil der MASM32 High-Level-Syntax (.while / .endw / .if / .endif

    In Assembler gibt es Register, das sind Speicherbereiche, die 4 Bytes (Long-Integer) groß sind. Einige Register dürfen wahlweise auch nur 1 oder 2 Bytes groß sein. Diese Register heißen eax, ebx, ecx, edx, edi und esi. Dann gibt es noch ebp, das wir aber erstmal ausser acht lassen. Und es gibt noch esp, das ist auch erstmal tabu. Zudem benutzt Assembler esp als Stackpointer. Edi und esi sind entweder 2 oder 4 Byte groß, eax, ebx, ecxedx können als Long, Integer oder Byte vorkommen. Als Integer heißen sie dann ax, bx, cx und dx. Esi und edi heißen als Integer si und di.
    Bei den Byte-Registern gibt es einmal das HiByte und das LoByte. Eax, ebx, ecx und edx heißen dann ah und al, bh und bl, ch und cl und noch dh und dl.
    Hier mal ein Beispiel der Bitbelegung des Registers eax:

    Code
    |<-----------eax----------->|
    |.............|<----ax----->|
    |.............|<-ah->|<-al->|
    |------+------+------+------|
    | Bits | Bits | Bits | Bits |
    |31- 24|23- 16|15 - 8| 7 - 0|

    Eine wichtige Regel gibt es für Assembler: Es dürfen immer nur zwei Register mit der selben Byte-Größe zusammen benutzt werden! Aber was ist die Aufgabe eines Registers? Ein Register kann eine Zahl zwischenspeichern. Einige Assembler-Befehle können ein oder mehrere Register (untereinander) berechnen, vergleichen oder verändern. Darin besteht die ganze Technik.
    Variablen gibt es natürlich auch. Hier ein paar Beispiele (das Semikolon ist ein Kommentarzeichen. Alles was dahinter steht, wird nicht mehr als Code interpretiert):

    Code
    Werte dd 0,0,4,6,874,414425 ;6 Long-Ints
    Zahlen dw 45,263,4663 ;6 Integer
    dw 364,67,3
    Nochmehr db 4,5,1,90,34 ;5 Bytes
    Text db "Hallo",0 ;Und ein 6 bytes langer String (immer mit Nullbyte)


    Kommen wir zum ersten und wichtigsten Befehl: mov.

    Mov steht für Move und heißt "verschiebe". Man kann damit Zahlen in/aus ein(em) Register verschieben oder einen Registerwert in ein anderes Register kopieren. Der linke Wert ist das Ziel, der rechte Wert ist die Quelle.

    Code
    mov eax,4673052 ;die LongInt-Zahl 4673052 ins Register eax schreiben
    mov ebx,eax ;den Wert aus eax nach ebx schreiben, in ebx steht jetzt auch 4673052
    mov ax,20457 ;die Integer-Zahl 20457 nach ax
    mov ah,238 ;und das Byte 238 nach ah
    mov eax,variable ;variablenwert nach eax
    mov variable,eax ;und umgekehrt

    Add addiert zwei Werte miteinander und schreibt den neuen Wert in das linke Register:

    Code
    mov eax,10 ;10 nach eax
    add eax,20 ;20 addieren. Der Wert in eax ist jetzt 30
    mov ecx,5 ;5 nach ecx
    add eax,ecx ;ecx nach eax addieren. In eax steht jetzt der Wert 35

    Sub subtrahiert zwei Werte und schreibt den neuen Wert in das linke Register:

    Code
    mov eax,100 ;100 nach eax
    sub eax,30 ;30 subtrahieren. eax jetzt 70
    mov edx,10 ;10 nach edx
    sub eax,edx ;10 subtrahieren. eax ist jetzt 60

    Mul multipliziert zwei Werte und schreibt den neuen Wert nach eax. Bei einer Multiplikation dürfen nur eax und edx verwendet werden.
    Will man vorzeichenbehaftete Zahlen multiplizieren, dann muss anstatt dem mul das imul verwendet werden. mul ist in der Ausführung etwas schneller.

    Code
    mov eax,7 ;7 nach eax
    mov edx,5 ;5 nach edx
    mul edx ;7 x 5. In eax steht jetzt 35, in edx steht 0

    Div dividiert zwei Zahlen. An der Division sind drei Register daran beteiligt, eax, edx und ein Register ihrer Wahl. Edx muss Null sein!

    Code
    mov eax,100 ;100 nach eax
    mov edx,0 ;edx immer löschen!
    mov ebx,3 ;3 nach ebx
    div ebx ;eax geteilt durch ebx.
    ;Ergebnis (ganze Zahl) steht jetzt in eax, der Restwert in edx

    So jetzt können wir schonmal rechnen.

    Manchmal wünschen wir uns aber noch mehr Register. Die gibt's aber nicht. Aber wir können den Stack als Registerablage mißbrauchen.
    Mit push legen wir eine Variable oder ein Register auf dem Stack ab.

    Code
    push eax ;eax auf den Stack legen
    push ebx ;ebx auf den Stack

    Mit pop können wir den Wert wieder von Stack runternehmen. Das muss aber in umgekehrter Reihenfolge passieren. So z.B.:

    Code
    push eax
    push ebx
    push ecx
    pop ecx
    pop ebx
    pop eax

    Stellt euch den Stack als ein Stapel mit Briefen vor. Wenn ich drei Briefe daraufpacke, dann muss ich die beiden obersten erst wieder wegräumen, um an den ersten der drei Briefe zu gelangen.

    Jmp gleicht dem Basic-Befehl GOTO und wird für Schleifen und Sprünge benutzt. Hier ein Beispiel, dass auch gleich zeigt, wie Labels (Sprungmarken) benutzt werden:

    Code
    jmp hierhin[INDENT]mov eax,0
    mov ebx,0
    [/INDENT]hierhin:[INDENT]mov ebx,0
    [/INDENT]

    Lea ist ähnlich wie mov. Nur übergibt lea nicht den Wert einer Variablen oder eines Registers, sondern den Zeiger auf die Variable/Register, also die Adresse der Variablen im Speicher:

    Ups, die eckigen Klammern bedeuten, das nicht der Registerinhalt übergeben/gelesen wird, sondern der Inhalt, auf den das Register zeigt.

    Invoke ist eigentlich kein Assembler-Befehl, sondern auch schon High-Level-Syntax. Invoke startet eine Prozedure oder eine Dll-Funktion. Dahinter übergeben werden alle nötigen Parameter.

    Code
    invoke GetCurrentDirectory, 1024, addr speicherbereich

    Wenn eine API einen Rückgabewert übergibt, steht er nach dem Aufruf immer im Register eax. "addr speicherbereich" übergibt übrigens den Zeiger auf einen Variablenspeicher, ist aber nur bei invoke gestattet.
    Ebensogut hätte wir auch schreiben können:

    Code
    lea edx,speicherbereich
    invoke GetCurrentDirectory,255,edx

    So, das wären die versprochenen 10 Befehle :)
    Aber wie können wir jetzt Register und Variablen vergleichen und Bedingungen und Verzweigungen programmieren?
    Ganz einfach, den Rest können wir für den Anfang mit High-Level-Syntax machen. Ähnlich wie in Basic...

    .while und .endw ist das Assemblergegenstück zum bekannten While und EndWhile.

    Code
    mov eax,0
    .while eax == 1[INDENT]mov eax,[edx]
    add edx,4
     
    [/INDENT].endw

    .break und .continue gibt es auch, genauso wie z.B. in XProfan.

    Für Bedingungen und Verzweigungen gibt es .if, .elsif, .else und .endif.
    Und das funktioniert so wie in vielen Basic-Dialekten.

    Code
    .if eax==0[INDENT]mov ebx,1
    [/INDENT].elseif ecx==0[INDENT]mov edx,1
    [/INDENT].else[INDENT]mov ebx,2
    mov edx,2
    [/INDENT].endif

    Das == ist übrigens das Gleichzeichen. Weitere Vergleichsoperatoren sind:

    Code
    == Gleich
    != Ungleich
    > Größer als
    >= Größer gleich
    < Kleiner als
    <= Kleiner gleich
    ! Logisches NOT
    && Logisches AND
    || Logisches OR

    Sollen mehrere Bedingungen abgefragt werden, dann sollten die einzelnen Bedingungen in Klammen stehen, z.B.:

    Code
    .if ((eax==0) && (ebx>=0))

    Dann gibt es noch eine .repeat / .until Schleife, eine fußgesteuerte Schleife. Die wird so lange ausgeführt, bis die Bedingung hinter .until
    eintritt. In diesem Fall also, bis ebx gleich Null ist:

    Code
    .repeat[INDENT];irgendein Sourcecode
     
    [/INDENT].until ebx==0

    Eine .repeat / .until Schleife kann ebenfalls mittels .break verlassen, und mittels .continue neu gestartet werden.

    So, hier endet unser Assembler Crashkurs. Ich hab' wirklich alles für den Anfang Unnötige weggelassen. Das gibt dem User die Möglichkeit, von Grund auf anzufangen. Es gibt noch viele viele Befehle (Mnemonics) mehr, aber die meisten sind wirklich durch die konfortable High-Level-Syntax
    ersetzt worden. Anfänger jedenfalls werden mit den 10 beschriebene Befehlen schon gut zurecht kommen, und den Rest erledigt die alltägliche Routine.

    Ein gute Auflistung aller Assembler-Befehle gibt es hier: http://www.jegerlehner.ch/intel/IntelCodeTable.pdf

    Ich habe im ganzen Kurs darauf verzichtet, irgendwelche Optimierungen vorzunehmen (xor eax,eax anstatt mov eax,0), nur weil es ein paar Taktzyklen schneller ist. Assembler ist wirklich so schnell und die neuen Prozessoren arbeiten so gut, das solche Optimierungen heute kaum noch was hermachen. Einsteiger in Assembler sollten sich darum nicht damit belasten.

    Ich wünsche viel Spaß beim Lernen! :)

    • Anzeige

    Hallo!

    Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.

    • ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
    • ✔️ Deutsche Server & DSGVO-konform
    • ✔️ Persönlicher Support (kein 0815-Ticket-System)

    Mehr erfahren

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!