Deutscher Assembler-Crashkurs

[Paule]

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:

|<-----------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):

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.

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:

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:

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.

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!

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.

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.:

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:

jmp hierhin
mov eax,0
mov ebx,0
hierhin:
mov ebx,0

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:

.data ;Datenbereich kennzeichnen
vars dd 333,444,555,666 ;Hier 4 Longint's
 
.code ;Codebereich kennzeichnen
mov eax,vars ;In eax steht jetzt 333. Der erste Wert aus vars wird übergeben
lea edx,vars ;In edx steht jetzt der Zeiger auf vars
mov eax,[edx+0] ;333 nach eax. Das +0 könnte hier weggelassen werden
mov ebx,[edx+4] ;444 nach ebx
mov ecx,[edx+8] ;555 nach ecx
mov esi,[edx+12] ;666 nach esi
mov eax,222 ;222 nach eax
mov [edx+4],eax ;222 nach vars+4. Die 444 wird also durch 222 ausgetauscht.

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.

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:

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.

mov eax,0
.while eax == 1
mov eax,[edx]
add edx,4
 
.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.

.if eax==0
mov ebx,1
.elseif ecx==0
mov edx,1
.else
mov ebx,2
mov edx,2
.endif

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

== 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.:

.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:

.repeat
;irgendein Sourcecode
 
.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!