Angepinnt Deutscher Assembler-Crashkurs (32 Bit)

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • Deutscher Assembler-Crashkurs (32 Bit)

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

      [block]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 eine 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 usw.) unterstützt. Und davon ist einem Basic-Kenner schon vieles bekannt.

      In Assembler gibt es Register, das sind Speicherbereiche, die 4 Bytes (Long-Integer) groß sind. Diese Register heißen eax, ebx, ecx, edx, edi und esi. Dann gibt es noch ebp und esp, die wir aber erstmal ausser acht lassen, weil Assembler diese beiden letzten Register noch andersweitig benutzt.
      Bei einigen Registern können wir auch nur Teile davon benutzen, entweder 2 oder auch 1 ein Byte. Von Edi und esi können wir als Teile nur 2 Byte benutzen.
      Hier das Schema der Register:

      [Blockierte Grafik: http://img85.imageshack.us/img85/8855/asmregs.png]

      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 wird eax mit dem Wert in einem anderen Register malgenommen.
      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
      [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:

      .data ;Datenbereich kennzeichnen
      [INDENT] vars dd 333,444,555,666 ;Hier 4 Longint's
      [/INDENT] .code ;Codebereich kennzeichnen
      [INDENT] 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.
      [/INDENT]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
      [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.

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

      == 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
      [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: 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! :-)

      (w) Frank Abbing[/block]
      Gruß, Frank
    • @Frank

      Endlich - da habe ich schon lange drauf gewartet. Einen Crash-Kurs für Menschen wie mich. (Miese Englisch-Kenntnisse und nur 8 Jahre Volksschule) - Habe mir die Geschichte rauskopiert und werde das jetzt ausdrucken und heute abend anfangen, zu büffeln !
      Danke :lol: