Schnell-Kurs (Assembler)

Dies hier ist ein sehr kompakter Schnell-Kurs für Assembler.
Dabei werden die wichtigsten Eigenschaften zum Assembler-Programmieren erklärt.
In diesen Dokumenten sind grundsätzlich alle ASM-Funktionen und Register groß geschrieben, bei Variabeln und Namen wird nur der ersten Buchstaben groß geschrieben..

ASM ist im wesentlichen der Code der in direkter Prozessor- oder Maschinensprache geschrieben ist. ASM Programmen können daher viel effizienter sein als Hochsprachen Programme, und eine Runtime oder Compiler muß seine Code-Basis in ASM zur Verfügung haben.
Gerechnet wird in Registern, jede Operation muß also die Werte, zuerst in den entsprechenden Register verfügbar haben. Die Register sind sozusagen die Speicherstellen direkt im Prozessor. Das heißt, dass alle Werte zuerst einmal in diese Register kopiert werden müssen, um mit ihnen Rechnen zu können.
Da nicht unbegrenzt Register zur Verfügung stehen müssen Werte zT. zwischengespeichert werden, um Registerplätze wieder freizumachen. Dies kann im RAM Speicher geschehen oder in einem speziell dafür organisierten Speicher, welcher Stack (Stapel) genannt wird. Dieser Stack wird verwendet um Parameter zu übergeben oder Werte temporär zu speichern.
Da ständig mit Registern gearbeitet wird, muß der Inhalt der Register gesichert werden, um sicherzustellen, dass keine Informationen, die noch benötigt werden, überschrieben wird. Um dies soweit wie möglich zu verhindern geht man von sogenannten flüchtigen Registern aus, das heißt alle Register, außer EAX welches als Rückgabe Register verwendet wird, gelten als flüchtig. Der Compiler ist verantwortlich vor dem Sprung in eine Prozedur den Inhalt der Register zu sichern.
Alles befindet sich im gleichen RAM Speicher worauf der Prozessor zugreifen kann. Code, Daten und Stack benutzen also den gleichen Speicher. Um diese Speicherbereiche organisieren zu können, werden sie in Segmente aufgeteilt. Diese Speicher-Segmente werden über speziell dafür vorgesehene Segment-Register angesprochen.

Beschreibung-Kurz-CPU
OpCodes-CPU
Mathe-Integer

Mnemonic werden die Assembler (ASM) Funktionen genannt, sie repräsentieren direkten Binären Maschinen/Prozessoren Code in Textform lesbar geschrieben. Sie werden direkt vom ASM-Kompiler in Binärcode übersetzt.
Die Funktionen können 0 bis 3 Parameter enthalten, wobei der Parameter ganz links als Operand Funktionieren kann und gleichzeitig das Resultat speichert. In Binärcode (OpCode) können die Funktionen unterschiedlich lang sein, von minimal 1 Byte bis zu 6 und mehr Byte.

Mnemonic Ziel, Quelle
Mnemonic Ziel, Quelle1, Quelle2, Quelle3

In den alten 16Bit DOS-Systemen wurde der Speicher über die Kombination aus Segment-Register und Offset gebildet. Die Segmente konnten nur 64KB (65536 Byte) adressieren.
Das heutige Speichermodell ist Flat (Flach), das heißt das sich alle Informationen, Daten und Code, im gleichen Segment Befinden. Es ist ein Speicherzugriff auf 4GB direkt möglich. Dadurch wird ASM schneller und der Code übersichtlicher. Die Segment-Register FS GS werden normalerweise nicht verwendet, das Betriebssystem benutzt sie für bestimmte aufgaben.
Flat-Memory Model steht seit 386 zur Verfügung.

Im Real-Mode unter DOS war es möglich das Programme andere Speicherbereiche überschreiben konnten wenn meistens Programmierfehler dies versuchten. So konnten auch Betriebssystem Prozeduren überschrieben werden und ein Systemabsturz verursachen.
Im Protected-Mode wird der Speicherbereich kontrolliert in welcher ein Programm schreiben darf.

Die Daten werden im Speichern mit dem kleinsten Wert/Byte zuerst geschrieben, also umgekehrt als die Zahlen im Dezimalsystem.
Der Wert "4 3 2 1" (viertausend-dreihundert-einundzwanzig) würde im Speichern so abgelegt "01 02 03 04".

Die Register sind die im Prozessor vorhandenen Speicherfelder die für alle Operationen verwendet werden. Der Prozessor kann keine Operationen zB. aus dem RAM-Speicher direkt durchführen, alle Werte müssen zuerst in die entsprechenden Register kopiert werden.
Es gibt 8 Register mit zum Teil speziellen Aufgabenbereichen EAX EBX ECX EDX, ESI EDI, ESP EBP.

Für alle Register gilt:
8Bit Register bestehen aus 1 Zeichen und werden in Niedriges und Hohes Byte (Low Hight) unterteilt, also ?L ?H zB. AL.
16Bit Register bestehen aus 2 Zeichen, also ?X zB. AX.
32Bit Register erhalten noch ein zusätzliches E, also E?? zB. EAX.

? --> A B C D

Da diese mit allen Programmen und auch dem Betriebssystem in Multitasking geteilt werden, und es nur so wenige sind, gelten spezielle regeln zur effizienten und Sicheren Nutzung.

Dabei gilt...

Bei einem Call in eine Windows-API Funktion sollten sicherheitshalber alle Register gesichert werden die relevante Daten enthalten, welche nach dem Call noch benötigt werden.

Das Programm-Register enthält die aktuelle Position im Programmlauf. Es kann nicht direkt beeinflußt werden sondern nur indirekt über ASM-Funktionen die den Programmlauf beeinflussen.
Wird eine Funktion vom Prozessor ausgeführt, wird das Programm-Register um dessen Länge erhöht und zeigt somit auf die nächste Codeposition. (Nicht alle ProzessorFunktionen sind gleich lang.)
Die Zweite Möglichkeit sind Sprung-Funktionen wie Jump oder Loop.

Register können aber auf eine Stelle im Speicher zeigen, der Prozessor rechnet also direkt mit dem Wert im Register, oder holt sich den Wert von der Adresse aus dem RAM-Speicher auf die das Register Zeigt.
Es gibt mehrere Register die Heute fast alle Funktionen durchführen können. Doch sind bestimmte Register für spezielle Aufgaben besonders gut geeignet. Einige Operationen können nur über bestimmte Register durchgeführt werden.

(? --> LHX)

Die Register können unterschiedlich Lang sein, 8 16 32 Bit. Je nach Längen gibt es verschiedene Zeichen. Diese gelten für alle 4 Haupt-Regsiter.
(? --> A B C D)

Oder

Der Speicher ist eigentlich ein einziger riesiger Block. Um diese aber besser organisieren zu können verwendet ein Programm ein speziell Deklarierten Bereich für ein bestimmten Zweck. Diese Bereiche werden Segmente genannt. Zur Handhabung dieser Segmente gibt es spezielle Segment-Register.

Stack funktioniert, wie der Name (Stack = Stapel) schon sagt, wie eine Liste von Werten die auf diesen Stapel gelegt oder entfernt werden können.
Der Stack dient als temporärer Zwischenspeicher. Er ist dem Prozessor näher als der RAM Speicher und deshalb effizienter nutzbar. Zudem gibt es spezielle Prozessorfunktionen und -register, die den Stack verwenden können, um Werte zu speichern oder zu löschen. Diese Werte können wie eine Speicheradresse auch in Register geladen werden.
Der Speicherbereich des Stacks ist im Vergleich zum Arbeitsspeicher sehr begrenzt; wird zuviel Stackspeicher verwendet, kann ein Stacküberlauf-Fehler auftreten. Besonders kritisch sind dabei rekursive Prozeduren (Prozeduren, die sich selbst aufrufen), da bei jedem Aufruf Parameter, Rücksprungadresse und die lokalen Variabeln im Stack abgelegt werden. Es kann passieren, daß bei einer zu tiefen Rekursion der Stack überläuft und das Programm hart abstürzt.

Der Stack wird auch für die Parameterübergabe an Prozeduren (CALL, RET) verwendet. Wird also über ein CALL eine Prozedur aufgerufen, werden die Parameter (Werte, Referenzen, Zeiger) auf dem Stack abgelegt. Obwohl die aufrufende Prozedur dafür verantwortlich wäre, das, was sie auf den Stack gelegt hat, auch wieder von diesem zu entfernen, wird dies in der Praxis normalerweise über die Funktion RET erledigt, welche die zur aufgerufenen Prozedur gehörigen Parameter wieder vom Stack löscht und dann aus der Prozedur heraus springt. Eigentlich kann nur die aufrufende Prozedur wissen ob diese Parameter nicht vielleicht breites in der nächsten Operation wieder in gleicher Reihenfolge im Stack benötigt werden.

Erwähnenswert ist vielleicht noch, daß Stacküberlauf-Fehler auch von schädlicher Software genutzt werden können, um Code in Programme einzuschleusen. Dazu wird ein Stacküberlauf genutzt, um gezielt Programmcode so zu überschreiben, daß am Ende der fremde eingeschleuste Code statt des eigentlichen Programms ausgeführt wird. Besonders Programmierer von Sprachen wie C müssen besonders darauf achten, daß durch fehlerhafte Daten keine solchen Fehler im Programmcode auftreten können. Da C einen allfälligen Stacküberlauf nicht prüft und somit auch nicht als Fehler erkennt, ist es sogar möglich, daß manipulierte passive Daten wie Bilder, Musik usw. verwendet werden können, um Viren und andere schädliche Software auf andere Computer einzuschleusen.

Die Index-Register werden für Bereichsoperationen verwendet, also zB. Für String- oder Tabellen-Operationen.

Flags dienen dem Prozessor um zusätzliche Resultate zu den Registern zu speichern oder zu lesen. Ein Flag kann nur 2 Zustände speichern 0=Ungesetzt 1=Gestezt.
Jede ASM-Funktion kann so zB. Markieren ob das Resultat 0 oder Negativ ist, oder diese Information auswerten. Die Auswertung muß deshalb gleich nach der Funktion erfolgen.

ZF PF AF OF CF SF sind die Status-Flags, werden durch Operationen vom CPU gesetzt.
???alle Status-Flags werden vor einer Operation auf 0 gesetzt. Ihre Resultate geben Auskunft über die Eigenschaft des Resultats.

DF TF IF sind Steuerungsflags und werden vom Programm gesetzt um den Programmlauf zu beeinflussen.

  MOV EAX, ECX   ; EAX = ECX

  MOV EAX, [ECX]        ; EAX = Var1 (Wert auf die ECX im Speicher zeigt)
  MOV EAX, Var1         ; EAX = Var1 (Wert auf die Var1 im Speicher zeigt)
  MOV [EBX], EAX        ; EBX Adresse = EAX
  MOV Var1, EAX         ; Var1 Adresse = EAX
 
  LEA EAX, Var1         ; EAX = Adresse-Var (Kopiert die Adresse und nicht den Wert von Var1)
 
  LEA EAX, Var1         ; EAX = Adresse-Var (Kopiert die Adresse und nicht den Wert von Var1)
  MOV Var1P, EAX        ; Var1P = ist nun ein Pointer/Zeiger der auf Var1 Zeigt
 
  MOV EAX, Var1P        ; EAX = Var1P
  MOV EAX, [EAX]        ; Var1 (Wert auf die Var1P im Speicher zeigt, dereferenzieren)

  MOV EAX, 1            ; EAX = 1
  MOV EAX, "1"          ; EAX = ASCII(1)
  MOV EAX, 01h          ; EAX = HEX(1)

  MOV Var2, Var1        ;!!! Speicher-Adresse kann nicht direkt kopiert werden
  ;
  MOV EAX, Var1         ; über Register kopieren
  MOV Var2, EAX
  ;
  PUSH Var1             ; über Stack kopieren
  POP Var2

;Es können nur gleich lange Wörter miteinander berechnet werden
 
  MOV EAX, CL           ; FEHLER: da EAX 32-Bit und CL 8-Bit ist
 
;Diese müssen erst Konvertiert werden
 
  MOVZX EAX, CL         ; Mit 0 erweiterter Unsigned-Integer
  MOVSX EAX, CL         ; Signed-Integer (mit 00 oder FF erweitert je nach Vorzeichen.)
 
;(Alte Variante)
 
  MOV  AL, CL           ; copy CL INTO AL
  CBW                   ; convert BYTE in AL to WORD in AX
  CWDE                  ; convert WORD in AX to DWORD in EAX

;Um zB. in Tabellen eine Adresse im Speicher verwalten zu können, gibt es spezielle Adressierungs-Funktionen
 
  MOV EAX, [ BasisAddresse + Index * Skalierung + Offset ]  ; ([ BaseAddress + Index * Scale + Displacement ])
 
  MOV EAX, [EBX + ECX * 4 + 8]

  MOV AL, [EBX+ECX]        ; Für ein Byte-Array ohne Offset
 
  MOV EAX, [EBX+ECX*4]     ; Für ein Long-Array ohne Offset
 
 
;Für Lokale Arrays die als Parameter übergeben werden
    MOV EAX, [EBP-(displacement)]
 
;Diese Schreibweise ist erlaubt
    MOV EAX, Arr1[ECX*4]   ;=[EBP-(displacement)+ECX*4]

Signed bedeutet das die Zahl ein Negativ-Zeichen enthalten kann, dafür wird das letze Bit der Zahl verwendet, das anzeigt ob die Zahl positiv oder 0 ist (=0) oder negativ (=1). Dem Zahlenwert geht also ein Bit verloren.
Unsigned Werte verwenden alle Bits für den Zahlenwert und können deshalb nur 0 und Positive Werte abbilden.

Der Prozessor selbst unterscheiden nicht zwischen Signed- und Unsigned-Werten, es werden die gleichen Register verwendet. Für Addition und Subtraktion existieren noch nicht einmal besondere Funktionen, da sie nicht zwangsläufig notwendig sind wie bei Multiplikation und Division. Der Programmierer oder der Compiler ist dafür verantwortlich die Funktionen gemäß der Deklarationen der Variablen korrekt anzuwenden. zB. wird für eine Überlaufsprüfung bei einem Signed-Typ das Overflow-Flag OF geprüft, bei einem Unsigned-Typ das Carry-Flag CF.

Viele Operationen ermöglichen es nicht nur die Register zu verwenden, sondern auch Daten aus dem Speicher zu holen, und es sind auch Funktionen für Array/String möglich. Ebenso ist es möglich mit einem Register auf eine Speicheradresse zu verweisen. Hier sind nun eine Liste zusammengestellt, auf welche Weise der OpCode in Assembler umgesetzt werden kann. Aus denn Tabellen läßt sich ablesen welche Kombinationen erlaubt sind.
Zu beachtet ins ebenfalls das die Bitlängen nicht gemischt werden dürfen, alle Operatoren müssen die gleiche Bitlängen haben. Falls 16-Bit Daten mit 32-Bit Daten verarbeitet werden sollen, müssen diese erst über Konvertierungs-Funktionen aufeinander angepaßt werden.
Die Beispiele hier sind alle für 32-Bit Funktionen.

Adressioerung

MOV Beispiel

Speicher Adressierung

[Base + Index * Scale + Displacement]

    MOV   EAX, EBX                  ;Op   reg32, reg32
 
    MOV   EAX, DWord Ptr [Name1]    ;Op   reg32, mem
 
    MOV   EAX, [EBX]                ;Op   reg32, mem
    MOV   EAX, [EBX+ECX]            ;Op   reg32, mem
    MOV   EAX, [EBX+ECX*4]          ;Op   reg32, mem
    MOV   EAX, [EBX+ECX*4+1]        ;Op   reg32, mem
    MOV   EAX, [EBX+1]              ;Op   reg32, mem
    MOV   EAX, [ECX*4+1]            ;Op   reg32, mem
 
    MOV   EAX, -2                   ;Op   reg32, imm
    MOV   EAX, 0xFFFFFFFE           ;Op   reg32, imm
 
 
    MOV   DWord Ptr [Name1], EAX    ;Op   reg32, mem
    ;...

  PUSH Var2
  PUSH Var1
  CALL Proc1
 
  Proc1:
  MOV EAX, Var1         ; Var1 = [EBP+8]
  RET
 
;Alle Regster und Flags vor einem API-Call sichern (Ist langsam aber in Entwicklungszeit sinnvoll)
 
  PUSHAD                ; Sichert Alle Register (ohne Flags)
    ; Code zum Call
  POPAD
 
  PUSHFD                ; Sichert Alle Register und Flags
    ; Code zum Call
  POPFD

Man kann direkt mit Werten Arbeiten oder mit Werten auf die eine Adress-Zeiger verweist.

Dereferenzieren

Um Explizit anzugeben um welchen Daten-Typ es sich handelt gibt es Schlüsselwörter die Angeben wie Lang das Wort ist.

    RECT STRUCT
      left    DWORD  ?
      top     DWORD  ?
      right   DWORD  ?
      bottom  DWORD  ?
    RECT ENDS

Anmerkung :
Die Beispiele sind auch für eine aufsteigende Zählschleifen möglich.
In dem Fall wird das Zählregister vorher auf 0 gesetzt, statt dec, inc verwendet und der Schleifenabschluss wie bei der Fußgesteuerten Schleife mit einem vorher festgelegten Register verglichen.

; Hier Anfangwerte für Register 1 und 2 festlegen
 
Schleifenanfang:
CMP Register1,Register2
JNZ Schleifenende          ; Schleife umgehen, falls Register 1 und 2 unterschiedlich sind
 
   ; beliebig viele Anweisungen
   ; sinnvollerweise entweder Register 1 oder 2 auch verändern, sonst droht Endlosschleife
 
JMP Schleifenanfang
Schleifenende:

; Hier Anfangwerte für Register 1 und 2 festlegen
 
Schleifenanfang:
 
   ; beliebig viele Anweisungen
   ; sinnvollerweise entweder Register 1 oder 2 auch verändern, sonst droht Endlosschleife
 
CMP Register1,Register2
JNZ Schleifenanfang       ; Schleife wiederholen bis Register 1 = Register 2

 
; Hier ein Register zum Zählen vergeben
; und auf den gewünschten Maximalwert setzen(wie oft soll die Schleife durchlaufen ?)
 
Schleifenanfang:
 
   ; beliebig viele Anweisungen
   DEC reg_zaehlen ; Anzahl der noch durchzuführenden Durchläufe um 1 verringern
 
JNZ Schleifenanfang       ; Schleife wiederholen bis reg_zaehlen auf 0 gesunken ist

Anmerkung :
Das Ganze ist auch für eine aufsteigende Zählschleife möglich.
In dem Fall wird das Zählregister vorher auf 0 gesetzt, statt dec, inc verwendet
und der Schleifenabschluss wie bei der Fußgesteuerten Schleife mit einem vorher festgelegten
Register verglichen.

Daten ------------

Daten-Ende --------
Stack-Anfang EBP -----

Stack-Pointer ESP -----

Stack-Ende ----------

Code -----------

Code-Ende -----

Exceptions sind Fehler die der Prozessor erzeugt und die entweder abgefangen werden müssen, oder sogar zu einem Programmhalt führen können. Ein Typischer solcher Fehler ist zB. "Teilung durch 0" die in vielen Programmen auftreten kann wenn ein Wert 0 ist, obwohl dies nicht erwartet wurde.
Durch Fehlerabfang-Routinen können einige Exceptions abgefangen oder ein Programm beendet werden, je nach Compilierung mit Debuger-Informationen die beim Aufspüren des Fehlers helfen können.

Exceptions