Der Assembler - Universität zu Lübeck

Institut für Telematik | Universität zu Lübeck 

Informatik III 

Kapitel 3: Assembler 

Prof. Dr. Stefan Fischer 

Wintersemester 2005/2006

3-2 

Überblick 

• Was ist Assembler Programmierung? 

• Materialien 

• Erstes Assembler Beispiel 

• Speicher 

• Prozessor 

• Register 

• Aufbau eines Assembler Programms 

• Einfache Instruktionen 

• Der Stack 

• Funktionen 

• Von C zu Assembler: der Compiler 

• gdb – ein einfacher Debugger 

segment .text 

global asm_main 

asm_main: 

enter 0,0 

pusha 

mov ebx, 1 

dump_regs 1 

popa 

mov eax, 0 

leave 

ret 


Informatik III: Assembler

3-3 

Was ist Assembler-Programmierung? 

• Prozessoren stellen einen sogenannten Instruktionssatz 

(ISA) zur Verfügung 

• das ist die Menge aller Instruktionen, die direkt vom Prozessor 

ausgeführt werden können 

• Beispiele: 

- Addieren/Multiplizieren/Dividieren von zwei Zahlen 

- Zugriff auf den Speicher 

- Sprünge und Verzweigungen 

• Der Instruktionssatz ist unabhängig vom Betriebssystem 

• Die Instruktionen des Instruktionssatzes sind Binärzahlen: 

• Beispiel: 03 C3 

- IA-32 bzw. x86 (= 80x86, beinhaltet auch Pentium) Befehl 

- addiert und speichert zwei Zahlen 



3-4 

Kompilieren von Hochsprachen 

• Beim Kompilieren von Hochsprachen (C, C++, Pascal, 

etc.): 

• die Konstrukte der Hochsprache werden in den Instruktionssatz des 

Prozessors übersetzt 

• Besonderheiten des Betriebssystems werden berücksichtigt 

• daher abhängig von Prozessor und Betriebssystem 

• Manchmal möchte man jedoch direkt auf dem 

Instruktionssatz des Prozessors arbeiten 

• Das ist auf Basis von Binärzahlen jedoch sehr aufwendig 

und fehleranfällig 

• Daher: Assembler Programmierung 



3-5 

Was ist Assembler Programmierung? 

• Symbolische Schreibweise: 

• add eax, ebx 

• 

• semantisch äquivalent zu 03C3 

• Ein Assembler ist ein Programm mit folgende Aufgaben: 

• Übersetzen der symbolischen Schreibweise in binäre Instruktionen 

(assemblieren, assembly) 

- jede Instruktion in symbolischer Schreibweise = höchstens 

eine Instruktion in binärer Schreibweise (mit wenigen Ausnahmen) 

- Ergebnis des Übersetzens ist eine Objektdatei (.o), genau wie beim 

Übersetzen eines C Programms 

- die Objektdatei enthält Objektcode 

– Format ist betriebssystemspezifisch 

• Zusammenführen mehrerer Objektdateien zu einem ausführbaren 

Programm (linken, linking) 

- zum Teil betriebssystemspezifisch 



3-6 

Der Assembler 

• Es gibt viele verschiedene Assembler 

• Selbst für einen Prozessor unterscheidet sich die Syntax 

der symbolischen Befehle von Assembler zu Assembler 

• meist ist die Syntax jedoch zumindest ähnlich 

• Auch in Bezug auf die Unterstützung durch einen 

Präprozessor (z.B. für Makros) gibt es große Unterschiede 

• Im Rahmen der Vorlesung empfehlen und verwenden wir 

den NASM 

(Netwide Assembler) 

• open source 

• für DOS/Windows und Linux 

• http://sourceforge.net/projects/nasm 



3-7 

Unterschied von Assemblieren und Kompilieren 

• In höheren Programmiersprachen (C/C++/etc.): 

• Kompilieren, um aus dem Quelltext eine Objektdatei mit 

Objektcode zu erzeugen 

- ähnlich wie Assemblieren 

• Aber: hier werden die Instruktionen der Programmiersprache vom 

Compiler in viele Instruktionen des Befehlssatzes übersetzt 

- der Optimierungsgrad kann beim Übersetzen durch Parameter 

gesteuert werden 

- ebenso kann man durch Parameter bestimmen, ob die Besonderheiten 

eines Prozessors (MMX/ISSE) verwendet werden sollen 

- man hat keine vollständige Kontrolle darüber, welche Instruktionen des 

Befehlssatzes erzeugt werden 

• Bei der Assembler Programmierung: 

• Programmierer hat genaue Kontrolle darüber, welche Instruktion 

erzeugt wird 

• sehr viel direktere und einfachere Übersetzung als beim 

Kompilieren 



3-8 

Einbetten in C 

• Meist werden Programme nicht komplett in Assembler 

geschrieben: 

• sehr aufwändig 

• sehr fehleranfällig 

• Statt dessen: 

• einzelne Funktionen werden in Assembler geschrieben 

• die Funktionen werden dann von einer höheren 

Programmiersprache aus aufgerufen 

• Vorgehen bei C: 

• C Programm mit Funktionsaufruf schreiben und kompilieren 

• Assembler Programm für diese Funktion schreiben und 

assemblieren 

• Linken der Objektdateien 



3-9 

Warum Assembler Programmierung? 

• Drei zentrale Gründe: 

• zur Optimierung von besonders kritischen und wichtigen 

Stellen eines Programms 

- genaue Kontrolle über die verwendeten Instruktionen 

- Nutzen hierfür nimmt ab: Compiler werden immer besser! 

• zum Zugriff auf Funktionalität die durch höhere 

Programmiersprachen nicht direkt angesprochen 

werden kann 

- Beispiele: MMX, 3DNow!, ISSE2 

- werden jedoch auch zunehmend gut von Compilern unterstützt 

• der wichtigste: Verstehen wie ein Computer arbeitet! 



3-10 

Materialien 

• Assembler Programmierung in 3 Schritten: 

• Kurzeinführung in der Vorlesung (x86/IA-32 Assembler) 

• Paul A Carter, „PC Assembly Language“, 2005 

- verfügbar unter http://www.drpaulcarter.com/pcasm/ 

• Verwendete Tools: 

• NASM (assemblieren) 

http://sourceforge.net/projects/nasm 

• Handbuch zu NASM (Link auf der Webseite zur 

Vorlesung) 

• gcc (compilieren und linken) 

- für DOS/Windows: DJGPP (http://www.delorie.com/djgpp/) 

• sind im Pool installiert 



3-11 

Erstes Assembler Beispiel 

• Das C Programm für das erste Assembler Beispiel 

• cdecl.h enthält die Definitionen von PRE_CDECL und 

POST_CDECL 

• regelt wie C Assembler Funktionen aufruft 

• Alles andere: wie immer 

• inkl. Deklaration einer Funktion int asm_main(void); 

#include "cdecl.h" 

int PRE_CDECL asm_main( void ) POST_CDECL; 

int main() 

{ 

int ret_status; 

ret_status = asm_main(); 

return ret_status; 

} 



3-12 

Erstes Assembler Beispiel 

• Zeilen die mit % beginnen sind Anweisungen an den NASM 

Präprozessor (analog zu # in C) 

• In asm_io.inc werden einige Hilfsmakros definiert, z.B. eines zur 

Ausgabe aller Registerinhalte (dump_regs 1) 

• Unter DOS/Windows: _asm_main statt asm_main 

%include "asm_io.inc" 

segment .text 


asm_main: 

enter 0,0 ; Funktionseintritt 

pusha 


mov ebx, 1 ; lade eine 1 in das Register ebx 

dump_regs 1 ; gib Register aus 

popa ; nach C zurückkehren 

mov eax, 0 

; Rückgabeparameter setzen 

leave 

ret 


3-13 

Assemblieren, Kompilieren, Linken 

• Assemblieren: 

• nasm -f elf Program1.asm (linux) 

• nasm -f coff Program1.asm (dos) 

• erzeugt eine Objektdatei: Program1.o 

• Kompilieren: 

• gcc -c driver.c 

• Linken: 

• gcc -o first driver.o Program1.o asm_io.o 

• asm_io beinhaltet den Objektcode für die Ausgaberoutinen, die in 

asm_io.inc deklariert wurden 

• Ergebnis: first.exe (dos) oder first (linux) 



3-14 

Ausgabe 

• In das Register EBX wurde eine 1 geladen 

Register Dump # 1 

EAX = 00000000 EBX = 00000001 ECX = 00000001 EDX = 401570C0 

ESI = 40014020 EDI = BFFFDCB4 EBP = BFFFDC58 ESP = BFFFDC38 

EIP = 0804841A FLAGS = 0286 SF PF 



3-15 

Speicher 

• Der Speicher ist üblicherweise in Bytes aufgeteilt 

• Jedes Byte umfasst 8 Bit 

• Instruktionen arbeiten auf einem oder mehreren Bytes 

• Je nach Anzahl der Bytes verwendet man bei x86 

Prozessoren die folgenden Begriffe: 

• word = 2 Byte 

• double word = 4 byte 

• quad word = 8 byte 

• paragraph = 16 byte 

• Die Bytes im Speicher sind durchnummeriert, die Nummer 

eines Bytes bezeichnet man als seine Adresse 



3-16 

Endianess 

• Wie speichert man einen Wert, der aus mehreren Bytes besteht (z.B. 32 Bit 

unsigned Integer)? 

• Zwei Möglichkeiten: 

• Big Endian: 

- Das höchstwertige Byte wird in der kleinsten Adresse gespeichert 

- Beispiel 0xA0B70708 wird wie folgt an der Adresse 800 gespeichert 

– A0 in der Speicherzelle mit der Adresse 800 

– B7 in 801, 07 in 802, 08 in 803 

- Beispiele: Motorola 68000, SPARC, IBM 370 

• Little Endian: 

- Das höchstwertige Byte wird in der größten Adresse gespeichert 

- Beispiel 0xA0B70708 wird wie folgt an der Adresse 800 gespeichert 

– A0 in der Speicherzelle mit der Adresse 803 

– B7 in 802, 07 in 801, 08 in 800 

- Beispiele: MOS Technologies 6502, Intel x86, DEC VAX 



3-17 

Wann ist Endianess wichtig? 

• Im normalen Betrieb merkt man nicht ob ein 

Prozessor Big oder Little Endian verwendet 

• sowohl lesender als auch schreibender Zugriff 

verwendet immer die gleiche Endianess 

• Problematisch wird es, wenn: 

• man zwischen zwei Rechnern mit verschiedener 

Endianess Daten austauscht 

• man dieselben Daten in unterschiedlichen Einheiten 

manipuliert 

- also z.B. auf ein 32-bit Unsigned Integer Wert byteweise zugreift 



3-18 

Prozessor 

• Der Prozessor stellt den Instruktionssatz zur 

Verfügung 

• Dieser Instruktionssatz unterscheidet sich i.d.R. 

von Prozessor zu Prozessor 

• Wir verwenden den Instruktionssatz der Intel x86 

Familie 

• wird auch IA-32 (Intel Architecture 32) genannt 

• ab 80386, bis zum aktuellen Pentium, aktuelle AMD 

Prozessoren 

• Erweiterungen MMX, ISSE 

• 32-bit ist die natürliche Größe für Operanden und 

Adressen 



3-19 

Register 

• Im Prozessor gibt es die schon genannten 

Register: 

• dies sind Speicherzellen 

• auf die besonders schnell zugegriffen werden kann 

• die teilweise besondere Bedeutung bei verschiedenen 

Instruktionen haben 

• Viele Operationen verwenden Register als 

Operanden oder zum Speichern des Ergebnisses 



3-20 

Speichermodelle 

• Real Mode, Flat Model: ab Intel 8080 

• 64K für alles (Programm und Daten) 

• Betriebssysteme: CP/M-80, später DOS 

• Real Mode, Segmented Model: ab Intel 8086 

• für die Kompatibilität mit 8080: Einteilung des Speichers in 64k 

Blöcke 

• man muss manuell festlegen welchen Block man gerade verwendet 

• sehr aufwändig und fehleranfällig 

• Betriebssysteme: DOS 

• Protected Mode: ab Intel 80386 

• 4GB virtueller Speicher für alles (Programm und Daten) 

• Betriebssysteme: Windows, Linux 



3-21 

Register des Pentium 

• Entwicklungsgeschichte (8086 von 

1978!) kann aus dem Registersatz 

abgelesen werden 

• E = Extended = 32 bit 

• EAX, EBX, ECX, EDX 

• Allgemeine 32 bit Register, aber: 

• EAX: Berechnungen 

• EBX: Zeiger (Pointer) 

• ECX: Schleifen 

• EDX: Mult/Div, 64 bit mit EAX 

• 16 and 8 bit Teile (286, 8088) 

• ESI, EDI: String Operationen 

• EBP, ESP: Base/Stack Pointer 

• CS-GS: Speicher Segment Zugriff 

• EIP: Instruction Counter (=PC) 

• EFLAGS: Prozessorstatuswort 

Für den Anwendungsprogrammierer 

nur 

unter Real Mode, 

Segmented Model 

sichtbar! 



3-22 

EFLAGS-Register 

• Das EFLAGS-Register hat eine besondere Bedeutung: 

• es gibt den Status des Prozessors an 

• es erteilt Informationen über die letzte Berechnung 

• jedes Bit in diesem Register hat eine eigene Bedeutung 


- Sign Flag (S): 

– im Ergebnis der letzten Operation war das höchstwertige Bit gesetzt 

- Zero Flag (Z): 

– das Ergebnis der letzten Operation war 0 

- Carry Flag (C): 

– bei der letzten Operation gab es einen Übertrag 

- Overflow Flag (O) 

– bei der letzten Operation gab es einen Überlauf 

• die Flags des EFLAGS-Registers können mit speziellen 

Instruktionen abgefragt werden 

- Realisieren bedingter Sprünge 



3-23 

Aufbau eines Assembler Programms (NASM) 

• Ein Programm kann aus mehreren Übersetzungseinheiten 

bestehen 

• Eine Übersetzungseinheit wird Modul genannt 

• Ein Modul kann die folgenden Elemente beinhalten: 

• Segmentidentifikation 

• Assembler Instruktionen 

• Pseudo Instruktionen 

• Preprozessor Anweisungen 

• Direktiven an den Assembler (beinhaltet Segmentidentifikation) 

• Dies ist Assembler spezifisch (also hier für NASM), von 

den Grundzügen her aber typisch für x86 Assembler 



3-24 

Segmentidentifikation 

• Eine Übersetzungseinheit kann aus mehreren 

(Speicher)Bereichen bestehen 


• .text: in diesem Bereich befinden sich die ausführbaren 

Instruktionen 

• .data: in diesem Bereich befinden sich „Variablen“ mit 

vordefinierten Werten 

• .bss: (block start symbol) in diesem Bereich befinden sich 

„Variablen“ die keinen vordefinierten Wert besitzen 

• Diese Bereiche nennt man Segmente oder Sektionen 

• Der Beginn eines Segmentes wird mit dem Assembler Direktiv 

SEGMENT (oder wahlweise SECTION) gekennzeichnet 

• Beispiel: %include "asm_io.inc" 


segment .text 


asm_main: 


... Informatik III: Assembler

3-25 

Assembler Instruktion 

• Assembler Instruktionen werden vom Assembler in Instruktionen des 

Befehlssatzes des Prozessors übersetzt 

• In NASM haben Assembler Instruktionen folgendes Format: 

: ; 

• Beispiel: 

loop1: mov ebx, 1 ; Start of Loop, initialize ebx 

• label 

• Damit kann diese Zeile identifiziert werden, ohne dass man mühsam die 

Speicheradresse dieser Zeile bestimmen muss 

- Das Bestimmen der Speicheradresse übernimmt der Assembler für uns 

• Ein definierter Label kann anstelle einer Adresse geschrieben werden, z.B. 

- um den Ort zu identifizieren an dem Daten abgelegt sind 

- um Ziele von Verzweigungen oder Sprüngen zu identifizieren 



3-26 

Assembler Instruktion 

• instruction 

• die eigentliche Assembler Instruktion 

• operands 

• je nach Instruktion können Operanden folgen 

• Operanden können 

- direkt angegeben werden (als Konstante) 

- in einem Register stehen 

- im Speicher stehen 

• comment 

• alles nach dem ; wird ignoriert 

• Zeilenverlängerung: ein Assembler Instruktion muss in 

einer Zeile stehen 

• Verlängerung einer Zeile durch \ als abschließendes Zeichen 

möglich 



3-27 

Spezifikation von Instruktionen 

• Auszug aus dem NASM Handbuch: 

MOV r/m8,reg8 ; 88 /r [8086] 

MOV r/m16,reg16 ; o16 89 /r [8086] 

MOV r/m32,reg32 ; o32 89 /r [386] 

MOV reg8,r/m8 ; 8A /r [8086] 

MOV reg16,r/m16 ; o16 8B /r [8086] 

MOV reg32,r/m32 ; o32 8B /r [386] 

... 

• Dies gibt an welche Operanden erlaubt sind: 

• regX=Register der Größe X 

• mX=Speicher der Größe X 

• r/mX=Register oder Speicher der Größe X 

• immX=direkte Angabe des Operanden der Größe X 

• ... 

• Dann folgt die Beschreibung welche Instruktion des Befehlssatzes des 

Prozessors generiert wird 

• Dann der Prozessor ab dem die Instruktion vorhanden ist 



3-28 

Erlaubte Adressierung von Operanden 

• Immediate: Operand als Konstante angeben 

• nur für Operanden die kein Ziel für eine Operation sind 

• mov eax, 0 

• Register: Register angeben 

• für Operanden die Ziel oder Quelle für eine Operation sind 

• mov eax, ebx 

• Speicher: Adresse der Speicherzelle in [] angeben 

• nur ein Operand darf direkt auf diese Art adressiert werden 

• mov eax, [esp] 



3-29 

Typische Addressierungsfehler 

• mov 17, 1 

• nur ein Operand darf Immediate adressiert werden 

• mov 17, bx 

• Ziel darf nicht Immediate adressiert werden 

• mov cx, dh 

• beide Operanden müssen die gleiche Größe haben 

• mov [ax],[bx] 

• nur ein Operand darf direkt im Speicher adressiert 

werden 



3-30 

Speicherzugriff 

• Wenn ein Operand im Speicher steht wird die Adresse des 

Operanden so angegeben: [Adresse] 

• Beispiele ohne Speicherzugriff: 

• mov eax, 1 ; lädt eine 1 in das Register eax 

• Sei loop1 ein label, dann 

mov eax, loop1 ; lädt die Adresse von loop1 in eax 

• Beispiele mit Speicherzugriff: 

• Sei buffer ein label, dann 

mov eax, [buffer] ; lädt 4 Bytes aus dem Speicher beginnend \ 

mit dem Byte an der Speicherstelle buffer 

• mov eax, [ecx+ebx*4+0x800] ; lädt 4 Bytes aus dem Speicher \ 

beginnend mit dem Byte an der \ 

Speicherstelle ecx+ebx*4+0x800 

- dieses Konstrukt benötigt man z.B. um effizient über ein Array iterieren 

zu können 



3-31 

Speicheradressierung 

• Erlaubte Adressierung: [BASE+(INDEX*SCALE)+DISP] 

• BASE: EAX, EBX, ECX, EDX + deren verkürzte Varianten 

- z.B.: Adresse des ersten Wertes in einem Array 

• INDEX: EAX, EBX, ECX, EDX + deren verkürzte Varianten 

- z.B.: Index eines Array Elementes 

• SCALE: 1, 2, 4 oder 8 

- z.B.: Größe eines Array Elementes 

• DISP: 32-Bit Konstante 

- z.B. um einen konstanten Offset in eine Tabelle zu addieren 

• Alle Elemente sind optional 



3-32 

Datentypen 

• In Assembler ist der Datentyp eines Operanden seine 

Länge in Bytes 

• Hat eine Instruktion mehr als einen Operanden: 

• dann muss die Länge der Operanden meist identisch sein: 

- mov eax, ebx ist korrekt 

- mov eax, bx ist nicht korrekt 

• Die Länge eines Operanden kann implizit angegeben sein: 

• z.B. bei mov eax, 0x10 wird 0x10 als 32-Bit Zahl interpretiert 

• Explizite Angabe der Länge eines Operanden ist 

erforderlich, wenn sie implizit nicht bestimmt werden kann: 

• z.B. bei neg byte [wert] 

• erlaubte Type Specifiers: byte, word, dword 



3-33 

Pseudoinstruktionen 

• Pseudoinstruktionen werden nicht direkt in Instruktionen 

des Befehlssatzes übersetzt 

• Sie haben aber das gleiche Format wie Assembler 

Instruktionen 

• Man verwendet Pseudo Instruktionen zum Beispiel für 

• das Bereitstellen von initialisiertem Speicherplatz (meist im 

.data Segment): 

- db 0x55 ; Speicherplatz der Größe 1 Byte belegt mit 0x55 

- db 0x55, 0x56, 0x57 ; drei aufeinander folgende Bytes 

- db 'hello',13,10,'$‘ ; 8 aufeinander folgende Bytes 

- dw 0x1234 ; 0x34 0x12 (little endian) 

- dw 'abc‘ ; 0x61 0x62 0x63 0x00 (Auffüllen auf Wort Grenzen) 

- dd 0x12345678 ; 0x78 0x56 0x34 0x12 (little endian) 

• das Bereitstellen von uninitialisiertem Speicherplatz (meist im 

.bss Segment): 

- buffer: resb 64 ; 64 * 1 Byte reserviert 



3-34 

Konstanten 

• In NASM gibt es 4 verschiedene Arten von Konstanten: 

• numeric, character, string, (floating-point) 

• numeric (überall wo die direkte Angabe eines Operanden erlaubt ist): 

• standard: Dezimal 

- mov ax, 100 

• Hexadezimal durch 

- den Präfix 0x (Beispiel: mov ax, 0xa0) 

- den Suffix h (Beispiel: mov ax, 0a0h) 

– Achtung! die Zahl muss mit einer Ziffer beginnen, daher die '0' 

- den Präfix $ (Beispiel: mov ax, $0a0) 

– Achtung! die Zahl muss mit einer Ziffer beginnen, daher die '0' 

• Oktal durch q oder o als Suffix 

- mov ax, 777q 

- mov ax, 777o 

• Binär durch b als Suffix 

- mov ax, 10010011b 



3-35 

Konstanten 

• character (überall wo die direkte Angabe eines Operanden 

erlaubt ist): 

• bis zu 4 Zeichen in einfachen oder doppelten Anführungszeichen 

• Little Endian wird berücksichtigt: 

- mov eax, 'abcd' ; danach steht 0x64636261 in eax 

• string (nur bei den Pseudoinstruktionen DB/DW/DD und 

INCBIN): 

• beliebig lange Kette von Zeichen in einfachen oder doppelten 

Anführungszeichen 

• es wird immer auf die „richtige“ Größe aufgefüllt 

- DB=ein Byte, DW=zwei Byte, DD=vier Byte 

• die Reihenfolge im Speicher ist so wie angegeben 

- db 'hello' ; ist äquivalent zu 

- db 'h','e','l','l','o' 

- dd 'ninechars' ; ist äquivalent zu 

- dd 'ninechars',0,0,0 



3-36 

Rückblick 

• Speicher (Endianess), Prozessor, Register 

• Aufbau eines Assembler Programms 

• Segmentidentifikation (.TEXT .DATA .BSS) 

• Instruktionen: : ; 

 

- Adressierung von Operanden: immediate, Register, Speicher 

- Speicheradressierung: [BASE+(INDEX*SCALE)+DISP] 

• Pseudoinstruktionen: zur Reservierung von Speicher 



3-37 

Beispiel: Addieren von zwei Zahlen 


segment .data 

wert1: 

wert2: 

dd 0x20 

dd 0x40 

segment .bss 

resultat: resd 1 

segment .text 


asm_main: 

enter 0,0 

pusha 

mov eax, [wert1] 

add eax, [wert2] 

mov [resultat], eax 

dump_regs 1 

; Funktion initialisieren 

; Ersten Operanden laden 

; Zweiten Operanden hinzuaddieren 

; Ergebnis speichern 

; Ausgabe der Registerwerte 


popa 

mov eax, 0 

leave 

ret 

Informatik III: Assembler 

; Zu C zurückkehren

3-38 

Addieren von zwei Zahlen - Resultat 

fischer@picard:~/cvs/lehre/info3/vorlesung/assembler$ ./first 


EAX = 00000060 EBX = 40155B90 ECX = 00000001 EDX = 401570C0 

ESI = 40014020 EDI = BFFFEBB4 EBP = BFFFEB58 ESP = BFFFEB38 

EIP = 08048425 FLAGS = 0206 



3-39 

Der Präprozessor 

• Analog zu C unterstützt auch NASM einen Präprozessor 

• Dieser wird vor dem eigentlichen Übersetzen ausgeführt 

• Anweisungen an den Präprozessor sind mit % 

gekennzeichnet 

• Beispiel: %include“asm_io.inc“ 

• fügt den Inhalt der datei asm_io.inc an diese Stelle ein 

• Sehr mächtig: 

• genaueres im NASM Handbuch (Kapitel 4) 



3-40 

Einfache Instruktionen 

• Kopieren von Daten (mov, bekannt!) 

• Arithmetische Integerinstruktionen 

• Logische Instruktionen 

• Verschiebe Instruktionen 

• Rotations Instruktionen 

• Unbedingte und bedingte Sprünge 

• Vergleiche 

• Schleifen 

• Setzen/Löschen von Flags 



3-41 

Arithmetische Integer Instruktionen 

• Addieren von ganzen Zahlen: 

• add op1, op2 (ohne Berücksichtigung des Carry 

(Übertrag) Flags) 

- op1=op1+op2 

• adc op1, op2 (mit Berücksichtigung des Carry Flags) 

- op1=op1+op2+C 

• Subtrahieren von ganzen Zahlen: 

• sub op1, op2 (ohne Berücksichtigung des Carry Flags) 

- op1=op1-op2 

• sbb op1, op2 (mit Berücksichtigung des Carry/Borrow 

Flags) 

- op1=op1-op2-C 



3-42 

Beispiel 

segment .data 

wert1: 

wert2: 

dd 0x00000000, 0xFFFFFFFF 

dd 0x00000000, 0x00000001 

segment .bss 

resultat: resd 2 

segment .text 


asm_main: 

... 

mov eax, [wert1+4] ; Operanden laden 

mov ebx, [wert1] 

mov ecx, [wert2+4] 

mov edx, [wert2] 

dump_regs 1 ; Ausgabe der Register 

add eax, ecx ; Addition der unteren 32 Bit 


adc ebx, edx ; Addition der oberen 32 Bit 


mov [resultat], eax ; Ergebnis speichern 

mov [resultat+4], ebx 

... 



3-43 

Beispiel 

... 

mov eax, [wert1+4] ; Operanden laden 

mov ebx, [wert1] 

mov ecx, [wert2+4] 

mov edx, [wert2] 


add eax, ecx ; Addition der unteren 32 Bit 


adc ebx, edx ; Addition der oberen 32 Bit 


mov [resultat], eax ; Ergebnis speichern 

mov [resultat+4], ebx 

... 

Ausgabe: 


EAX = FFFFFFFF EBX = 00000000 ECX = 00000001 EDX = 00000000 

ESI = 40014580 EDI = BFFFF544 EBP = BFFFF4E8 ESP = BFFFF4C8 

EIP = 0804844C FLAGS = 200286 SF PF 


EAX = 00000000 EBX = 00000000 ECX = 00000001 EDX = 00000000 


EIP = 08048458 FLAGS = 200257 

ZF AF PF CF 


EAX = 00000000 EBX = 00000001 ECX = 00000001 EDX = 00000000 


Informatik III: Assembler 

EIP = 08048464 FLAGS = 200202 

Prof. Dr. Stefan Fischer

3-44 

Arithmetische Integer Instruktionen 

• Multiplikation von ganzen Zahlen 

• mul op1 (Multiplikation von vorzeichenlosen Zahlen) 

- ax=al*op1 (bei 8 Bit op1) 

- dx:ax=ax*op1 (bei 16 Bit op1) 

- edx:eax=eax*op1 (bei 32 Bit op1) 

• imul op1 (Multiplikation von vorzeichenbehafteten Zahlen) 

- analog zu mul 

- weitere Formate (hier nicht besprochen) 

• Division von ganzen Zahlen 

• div op1 (Division von vorzeichenlosen Zahlen) 

- al=ax div op1 und ah=ax mod op1 (bei 8 Bit op1) 

- ax=dx:ax div op1 und dx=dx:ax mod op1 (bei 16 Bit op1) 

- eax=edx:eax div op1 und edx=edx:eax mod op1 (bei 32 Bit op1) 

• idiv op1 (Division von vorzeichenbehafteten Zahlen) 

- analog zu div 



3-45 

Beispiel für Multiplikation 

mov eax, 0xFFFFFFFF ; Operanden laden 

mov ecx, 0x00000010 

dump_regs 1 ; Registerwerte ausgeben 

mul ecx ; Multiplizieren 


Ausgabe: 


EAX = FFFFFFFF EBX = 401579A8 ECX = 00000010 EDX = 40158E90 


EIP = 0804843F FLAGS = 200286 SF PF 


EAX = FFFFFFF0 EBX = 401579A8 ECX = 00000010 EDX = 0000000F 


EIP = 0804844B FLAGS = 200A87 OF SF PF CF 



3-46 

Logische Instruktionen 

• and op1, op2 

• op1 = op1 AND op2 

• or op1, op2 

• op1 = op1 OR op2 

• xor op1, op2 

• op1 = op1 XOR op2 

• not op1 

• op1 = Einerkomplement von op1 (=alle Bits invertieren) 

• neg op1 

• op1 = Zweierkomplement von op1 (=(not op1)+1) 



3-47 

Verschiebe Instruktionen 

• shr op1, op2 (Shift Right) 

• op1 wird um op2 Stellen nach rechts verschoben 

• von links werden 0en nachgeschoben 

• shl op1, op2 (Shift Left) 

• op1 wird um op2 Stellen nach links verschoben 

• von rechts werden 0en nachgeschoben 

• sar op1, op2 (Shift Arithmetic Right) 

• op1 wird um op2 Stellen nach recht verschoben 

• von links wird die Ziffer nachgeschoben, die vorher im 

höchstwertigen Bit stand 

• Sign Extension! 

• sal op1, op2 (Shift Artithmetic Left) Synonym für shl 



3-48 

Rotations Instruktionen 

• ror op1, op2 (Rotate Right) 

• op1 wird um op2 Stellen nach rechts rotiert 

• von links wird das Bit übernommen, welches rechts herausrotiert 

wurde 

• rol op1, op2 (Rotate Left) 

• op1 wird um op2 Stellen nach links rotiert (analog zu ror) 

• rcr op1, op2 (Rotate Carry Rigth) 

• C:op1 wird um op2 Stellen nach rechts rotiert 

• von links wird das Bit übernommen, welches im Carry Flag stand 

• rechts wird in das Carry Bit hineinrotiert 

• rcl op1, op2 (Rotate Carry Left) 

• C:op1 wird um op2 Stellen nach links rotiert (analog zu rcr) 



3-49 

Bedingte Sprünge 

• Bisher lineare Ausführung von Instruktionen 

• jmp ende 

• unbedingter Sprung zur Instruktion mit dem Label ende 

• Bedingte Sprünge: 

• verzweigen, wenn Flags in EFLAGS Register gesetzt oder nicht 

gesetzt sind 

• Beispiel für einen bedingten Sprung: jo fehler 

• falls das Overflow (o) Flag gesetzt ist wird gesprungen 

• wenn nicht wird die nächste Instruktion ausgeführt 

• Sprungbefehle (Auszug): 

• jo, jno, jz, jnz, jc, jnc 



3-50 

Beispiel für bedingte Sprünge 

mov al, 01111111b ; Operanden laden, 2er Komplement 

mov bl, 00000001b 

add al, bl ; Addieren 


jno ende ; Überlauf abfangen 

mov al, 0x0 ; Bei Überlauf al auf 0 setzen 

ende: dump_regs 2 ; Registerwerte ausgeben 

Ausgabe: 


EAX = 00000080 EBX = 40157901 ECX = 401579A8 EDX = 40158E90 


EIP = 0804843B FLAGS = 200A92 OF SF AF 




EIP = 08048449 FLAGS = 200A92 OF SF AF 



3-51 

Vergleiche 

• Springen auf Grund von Vergleichen 

• cmp op1, op2 

• berechnet op1-op2 

• speichert kein Ergebnis 

• setzt aber die entsprechenden Flags im EFLAGS Register 

• bei vorzeichenlosen Zahlen: 

- op1=op2 wenn Z Flag gesetzt ist 

- op1op2 wenn Z und C Flag nicht gesetzt sind 

• bei vorzeichenbehafteten Zahlen: 

- ähnlich aber etwas komplizierter 

• Prinzipiell reicht das! 

• es ist aber nicht besonders praktisch, da mehrere Instruktionen für 

eine Auswahl benötigt werden 

• daher: spezielle bedingte Sprünge für die wichtigsten Fälle 



3-52 

Vergleiche 

• Beim Vergleich vorzeichenbehafteter Zahlen: 

• JE (op1==op2), JNE (op1!=op2) 

• JL und JNGE (op1=op2) 

• Beim Vergleich vorzeichenloser Zahlen 

• JE (op1==op2), JNE (op1!=op2) (wie oben!) 

• JB und JNAE (op1=op2) 



3-53 

Beispiel für Vergleiche 

mov eax, 0x10 ; Die größere der beiden Zahlen 

mov ebx, 0x20 ; soll in ecx gespeichert werden 

cmp eax, ebx ; Der Vergleich 


jl bgr 

mov ecx, eax 

jmp ende 

bgr: mov ecx, ebx 

ende: dump_regs 2 ; Registerwerte ausgeben 

Ausgabe: 




EIP = 08048441 FLAGS = 200287 SF PF CF 


EAX = 00000010 EBX = 00000020 ECX = 00000020 EDX = 40158E90 





3-54 

Schleifen 

• Für die “elegante” Unterstützung von for Schleifen 

gibt es folgende Instruktionen 

• loop marke 

- dekrementiert ecx 

- springt zum Label marke wenn danach ecx != 0 

• loope marke (loopz marke) 

- dekrementiert ecx (ohne EFLAGS zu modifizieren) 

- springt zum Label marke, wenn danach ecx != 0 und das Z Flag 

gesetzt ist 

• loopne marke (loopnz marke) 

- dekrementiert ecx (ohne EFLAGS zu modifizieren) 

- springt zum Label marke, wenn danach ecx != 0 und das Z Flag 

nicht gesetzt ist 



3-55 

Beispiel 

mov eax, 0 

mov ecx, 10 

start: add eax, ecx 

loop start 

dump_regs 1 

; eax enthält die Summe 

; ecx enthält die Obere Grenze 

; Aufsummieren 

; ecx dekrementieren und zurückspringen 

; Registerinhalte ausgeben 

Ausgabe: 


EAX = 00000037 EBX = 40155B90 ECX = 00000000 EDX = 401570C0 

ESI = 40014020 EDI = BFFFF2B4 EBP = BFFFF258 ESP = BFFFF234 

EIP = 08048403 FLAGS = 0202 



3-56 

Setzen und Löschen von Flags 

• Das Ausführen von Instruktionen kann den Status 

der Flags im EFLAGS Register verändern 

• Man kann insbesondere das Carry Flag auch 

gezielt setzen und löschen: 

• CLC zum Löschen des Carry-Flags 

• STC zum Setzen des Carry-Flags 

• CMC zum Invertieren des Carry-Flags 



3-57 

Der Stack 

• Bisher: 

• alle Daten entweder in einem Register 

• ... oder in einem festen Speicherplatz 

• schwierig wenn Funktionen realisiert werden sollen 

• ... die auch rekursiv aufrufbar sein sollen 

• Der Stack: 

• Datenstruktur aus Informatik I bekannt! 

• hier: ein Speicherbereich auf dem dynamisch Daten abgelegt 

werden können 

• der Stack beginnt bei einer hohen Speicheradresse und wächst 

nach unten 

• elementare Instruktionen sind push (ablegen auf Stack) und pop 

(herunternehmen vom Stack) 

• weitere Stack-Instruktionen für die Unterstützung von Funktionen 



3-58 

Beispiel für Elementare Stack Instruktionen 

• Der Stack hat einen 

Anfang, hier ist dieser 

bei der Adresse 0x2000 

• Der Stack hat ab dem 

80386 Prozessor 

üblicherweise eine 

Breite von 4 Byte 

• Man kann auch kürzere 

Daten auf den Stack 

legen, üblicherweise 

richtet man diese aber 

an 4 Byte Grenzen aus 

• ESP (Extended Stack 

Pointer) ist ein Register, 

welches auf den 

aktuellen Eintrag des 

Stacks zeigt 

Adresse: 0x2000 

0x1000 

● 

● 

4 Byte Breite 

... 

0x0000FFFF 

Nächste Aktion: 

push dword 1 

Bedeutung: 1 als ein Double 

Word (4 Byte) auf den 

Stack legen 

Anfang des Stacks 

ESP 



3-59 


• Aktuelle Aktion: 


4 Byte Breite 


push dword 1 

... 

• ESP wird um 4 

verringert 

0x1000 

0x0FFC 

0x0000FFFF 

0x00000001 

ESP 

• Dann wird in den 

Speicher auf den 

ESP zeigt die 1 

als ein Double 

Word (4 Byte) 

geschrieben 

● 

● 


push dword 2 

Bedeutung: 2 als ein Double 

Word (4 Byte) auf den 

Stack legen 



3-60 




4 Byte Breite 


push dword 2 

... 


verringert 

• Dann wird in den 

Speicher auf den 

ESP zeigt die 2 

als Double Word 

(4 Byte) 

geschrieben 

0x1000 

0x0FFC 

0x0FF8 

● 

● 

0x0000FFFF 

0x00000001 


pop eax 

0x00000002 

ESP 

Bedeutung: das oberste Double Word (4 Byte) 

vom Stack in das Register eax laden 



3-61 




4 Byte Breite 


pop eax 

... 

• Der Inhalt auf den 

ESP zeigt wird in 

das Register eax 

geschrieben 


erhöht 

0x1000 0x0000FFFF 

0x0FFC 0x00000001 

● 


pop ebx 

ESP 

● 

Bedeutung: das oberste Double Word (4 Byte) 

vom Stack in das Register ebx laden 



3-62 




4 Byte Breite 


pop ebx 

... 

• Der Inhalt auf den 

ESP zeigt wird in 

das Register ebx 

geschrieben 

0x1000 

0x0000FFFF 

ESP 


erhöht 

● 

Fertig! 



3-63 

Funktionen 

• Für die Unterstützung von Funktionen müssen 3 wichtige 

Probleme gelöst werden: 

• Rücksprungadresse merken (auf dem Stack) 

• Parameterübergabe regeln (auf dem Stack) 

• Übergabe des Rückgabewertes regeln (meist in eax) 

• Der Instruktionssatz stellt Hilfsmittel zur Lösung dieser 

Probleme zur Verfügung 

• Die Regelung wie diese Hilfsmittel angewendet werden ist 

abhängig von Compiler und Programmiersprache 

• Man nennt diese Regelung „Calling Convention“ 

• Wir betrachten in Folgenden die Calling Convention von C 

• Wenn man Assembler mit anderen Hochsprachen 

kombinieren will muss man deren Calling Convention 

verwenden 



3-64 

Rücksprungadresse merken: 

call und ret 

• In Assembler wird eine Funktion mit call aufgerufen: 

• Beispiel: call eingabe 

• ESP wird um 4 verringert, die Rücksprungadresse (Adresse des 

Befehls nach call) wird an diese Stelle gelegt (wie bei push) 

• dann wird zur Instruktion mit dem Label eingabe gesprungen 

• In Assembler kehrt man mit ret aus einer Funktion zurück: 

• Beispiel: ret 

• Das Register EIP wird vom Stack geladen, ESP wird um 4 erhöht 

- EIP ist der Extended Instruction Pointer, er zeigt auf den als nächstes 

auszuführenden Befehl 

• Dazu muss natürlich der ESP auf die richtige Position im Stack 

zeigen 

- problematisch wenn die Funktion den Stack selbst verwendet 



3-65 

Beispiel für Funktionsaufruf 

mov eax, 0x10 ; Die größere der beiden Zahlen 

mov ebx, 0x20 ; soll in ecx gespeichert werden 


dump_stack2 1,0,2 ; Stack ausgeben 

call max 


... 

max: dump_stack2 2,0,2 ; Stack ausgeben 

cmp eax, ebx ; Der Vergleich 

jl bgr 

mov ecx, eax 

jmp ende 

bgr: mov ecx, ebx 

ende: ret 



3-66 

Beispiel für Funktionsaufruf 

Ausgabe: 




EIP = 0804843F FLAGS = 200286 SF PF 

Stack Dump # 1 

EBP = BFFFF4E8 ESP = BFFFF4C8 

+8 BFFFF4D0 BFFFF4E8 

+4 BFFFF4CC 40014580 

+0 BFFFF4C8 BFFFF544 


EBP = BFFFF4E8 ESP = BFFFF4C4 

+8 BFFFF4CC 40014580 

+4 BFFFF4C8 BFFFF544 

+0 BFFFF4C4 08048462 


EAX = 00000010 EBX = 00000020 ECX = 00000020 EDX = 40158E90 





3-67 

Parameterübergabe 

• Bei den Calling Conventions von C werden 

Parameter auf dem Stack übergeben 

• Ablauf 

• der Aufrufer legt die Parameter auf den Stack (push) 

• der Aufrufer ruft die Funktion auf (call) 

• die Funktion wird bearbeit und beendet (ret) 

• der Aufrufer nimmt die Parameter vom Stack (add 

esp,wert) 

• Achtung: Parameter bleiben auf dem Stack liegen 



3-68 

Beispiel für Parameterübergabe 


push dword 0x10 ; Parameter auf den Stack legen 

push dword 0x20 

dump_stack2 1,0,2 ; Stack ausgeben 

call max ; Funktion aufrufen 


add esp, 8 ; Parameter vom Stack nehmen 

... 

max: mov ebx, [esp+8] 

cmp ebx, [esp+4] 

jl bkl 

mov eax, ebx 

jmp ende 

bkl: mov eax, [esp+4] 

ende: ret 

; Achtung Rücksprungadresse steht auf 

; dem Stack 

; Rückgabe über eax 


EBP = BFFFDF58 ESP = BFFFDF30 

+8 BFFFDF38 BFFFDFB4 

+4 BFFFDF34 00000010 

+0 BFFFDF30 00000020 


EAX = 00000020 EBX = 00000010 ECX = 00000001 EDX = 401570C0 

ESI = 40014020 EDI = BFFFDFB4 EBP = BFFFDF58 ESP = BFFFDF30 



3-69 

Lokale Variablen 

• Lokale Variablen werden ebenfalls auf dem Stack abgelegt 

• Wenn sich ESP innerhalb einer Funktion ändert wird es 

schwierig auf die Parameter und die lokalen Variablen 

zuzugreifen 

• Daher: ein weiteres spezielles Register 

• Extended Base Pointer (EBP) 

• EBP markiert den Beginn einer Funktion auf dem Stack 

• bei Funktionseintritt wird der alte Wert von EBP auf den Stack 

gelegt (push) 

- ... um ihn für die Rückkehr zur aufrufenden Funktion zu speichern 

• dann wird EBP der Wert von ESP zugewiesen 

• dann wird Platz für lokale Variablen geschaffen: 

- addiere zu ESP die Größe der lokalen Variablen 

• bei Funktionsende werden die lokalen Variablen vom Stack 

gelöscht und der alte Wert von EBP wieder hergestellt 



3-70 

Beispiel 

diff: dump_stack2 1,0,2 ; Stack ausgeben 

push ebp ; alter Wert von ebp sichern 

mov ebp, esp ; neuen Wert von ebp laden 

sub esp, 4 ; 4 Byte für lokale Variablen reservieren 

mov eax, [ebp+12] ; Parameter 1 in der lokalen Variablen speichern 

mov [ebp-4], eax 

mov eax, [ebp+8] ; Parameter 2 von der lokalen Variablen abziehen 

sub [ebp-4], eax ; danach müsste man sinnvoller Weise was damit 

; machen 

dump_stack2 2,0,4 ; wir geben es nur aus 

add esp, 4 

; lokale Variablen vom Stack nehmen 

pop ebp 

; ebp wieder herstellen 

ret ; zurück zum Aufrufer 


EBP = BFFFEBD8 ESP = BFFFEBAC 

+8 BFFFEBB4 00000020 

+4 BFFFEBB0 00000010 

+0 BFFFEBAC 08048404 


EBP = BFFFEBA8 ESP = BFFFEBA4 

+16 BFFFEBB4 00000020 

+12 BFFFEBB0 00000010 

+8 BFFFEBAC 08048404 

+4 BFFFEBA8 BFFFEBD8 

+0 BFFFEBA4 00000010 



3-71 

Vereinfachung 

• Das Setzen von ebp und das Reservieren von Speicher für 

lokale Variablen nennt man Prolog einer Funktion 

• Das Löschen der Variablen vom Stack und das 

Wiederherstellen von ebp nennt man Epilog einer Funktion 

• Da Prolog und Epilog sehr häufig vorkommen gibt es spezielle 

Instruktionen dafür: 

• enter op1, op2 

- push ebp 

- mov ebp, esp 

- sub esp op1 

- op2 wird bei den C Calling Conventions nicht benötigt 

• leave 

- mov esp, ebp 

- pop ebp 

• Achtung: enter benötigt mehr Zeit für die Ausführung als die 

einzelnen Instruktionen zusammen 



3-72 

Beispiel 

diff: dump_stack2 1,0,2 ; Stack ausgeben 

enter 4,0 ; ebp setzen, Platz für lokale Variablen schaffen 

mov eax, [ebp+12] ; Parameter 1 in der lokalen Variablen speichern 

mov [ebp-4], eax 

mov eax, [ebp+8] ; Parameter 2 von der lokalen Variablen abziehen 

sub [ebp-4], eax ; danach müsste man sinnvoller Weise was damit 

; machen 

dump_stack2 2,0,4 ; wir geben es nur aus 

leave ; lokale Variablen löschen, ebp wieder herstellen 

ret ; zurück zum Aufrufer 


EBP = BFFFEBD8 ESP = BFFFEBAC 

+8 BFFFEBB4 00000020 

+4 BFFFEBB0 00000010 

+0 BFFFEBAC 08048404 


EBP = BFFFEBA8 ESP = BFFFEBA4 

+16 BFFFEBB4 00000020 

+12 BFFFEBB0 00000010 

+8 BFFFEBAC 08048404 

+4 BFFFEBA8 BFFFEBD8 

+0 BFFFEBA4 00000010 



3-73 

Aufruf einer C-Funktion 

• C-Funktionen können direkt von Assembler aus aufgerufen 

werden 

• Parameter werden in umgekehrter Reihenfolge auf den 

Stack gelegt (der letzte Parameter als erstes) 

• Sinnvoll, da bei manchen Funktionen in C die Anzahl der 

Parameter variabel ist 

• Einer der nicht variablen Parameter bestimmt wie viele Parameter 

vorhanden sind 

• Die nicht variablen Parameter stehen damit relativ zum EBP an 

einer festen Stelle 

• Beispiel: printf(“x = %d\n“,100); 

• Unter Windows: „_“ dem Funktionsnamen voranstellen 

• Rückgabe: erfolgt bei Integer Werten über eax 



3-74 

Beispiel: Aufruf von printf 

extern printf ; Versprechen, dass das Symbol printf später hinzukommt 

segment .data 

x: dd 100 

format: db "X = %d",10,0 

; 10=lf, 0=Ende des Strings 

; (C Konvention) 

segment .text 


asm_main: 

enter 0,0 ; Funktion initialisieren 

pusha 

push dword [x] 

push dword format 

call printf 

add esp, 8 

; x auf den Stack legen 

; die Adresse! von format auf den Stack 

; legen 

; Funktion aufrufen 

popa ; Zu C zurückkehren 

mov eax, 0 

leave 

ret 

Ausgabe: X = 100 



3-75 

Retten von Registern 

• C erwartet, dass einige Register nach Rückkehr 

aus einer Funktion wieder ihren alten Wert 

beinhalten 

• Unterstützt durch pusha und popa: 

• pusha schreibt die Register EAX, ECX, EDX, EBX, 

ESP, EBP, ESI und EDI auf den Stack (=32 Byte) und 

reduziert dann ESP um 32 

• popa holt die Register in umgekehrter Reihenfolge vom 

Stack und erhöht ESP dann um 32 



3-76 

Beispiel 


segment .text 


asm_main: 


pusha 

mov ebx, 1 ; lade eine 1 in das Register ebx 

dump_regs 1 ; gib Register aus 

popa ; nach C zurückkehren 

mov eax, 0 

; Rückgabeparameter setzen 

leave 

ret 



3-77 

Stack Frame 

• Mit Stack Frame bezeichnet man den Bereich auf 

dem Stack, der zu einer Funktion gehört 

• Das ist der Bereich von EBP bis zum ESP: 

• alter EBP 

• gesicherte Register Inhalte 

• lokale Variablen 

• sonstiges 

• Achtung, übergebene Parameter gehören daher 

zum Stackframe der aufrufenden Funktion 

• darüber kann man sich streiten 



3-78 

Von C zu Assembler 

• Ein Kompiler übersetzt Programme einer Hochsprache in 

Instruktionen des Befehlssatzes eines Prozessors 

• Das kann man mit gcc sehr gut ausprobieren 

• Was macht gcc wenn er für eine .c Datei aufgerufen wird: 

• zuächst wird der C-Präprozessor (cpp) ausgeführt 

- Resultat: eine .C Datei 

• dann wird kompiliert, das C-Programm wird in ein Assembler 

Programm übersetzt 

- Resultat: eine .s Datei 

• dann wird assembliert (mit gas), das Assembler Programm wird in 

Instruktionen des Prozessors umgesetzt 

- Resultat: eine .o Datei 

• dann werden alle benötigten Dateinen und Bibliotheken 

zusammengelinkt (mit ld) 

- Resultat: ausführbares Programm 



3-79 

Beispiel 

#include 

int main() { 

printf("Hello World!\n"); 

return 0; 

} 

Übersetzen mit gcc hello.c -S 

Ergebnis: hello.s 



3-80 

Assembler Code 

.file "hello.c" 

.section .rodata 

.LC0: 

.string "Hello World!\n" 

.text 

.globl main 

.type main, @function 

main: 

pushl %ebp # push ebp 

movl %esp, %ebp # mov ebp, esp 

subl $8, %esp # sub esp, 8 

andl $-16, %esp # and eps, -16 (löscht die unteren 4 Bit) 

movl $0, %eax # mov eax, 0 

subl %eax, %esp # sub esp, eax 

movl $.LC0, (%esp) # mov esp, .LC0 

call printf # cal printf 

movl $0, %eax # mov eax, 0 

leave # leave 

ret # ret 

.size main, .-main 

.section .note.GNU-stack,"",@progbits 

.ident "GCC: (GNU) 3.3.2 20040119 (Gentoo Linux 3.3.2-r7)" 



3-81 

gdb – ein einfacher Debugger 

• Bisher: 

• Finden von Fehlern durch Ausgabe der Register 

• Umständlich und unpraktisch 

• Besser wäre: 

- Programm ab einem kritischen Punkt Schrittweise abarbeiten 

- Bei jedem Schritt Inhalt von Registern und Stack untersuchen 

• Dafür gibt es sogenannte Debugger: 

• Für alle Programmiersprachen 

• unterschiedlich komfortabel (Benutzeroberfläche) 

• für Java -> Behandlung im Programmierpraktikum 

• für Assembler: 

- gdb (GNU DeBugger) 

- unter Linux 

(unter Windows: debug, anderer Debugger, andere Befehle!) 

- Kommandozeile 



3-82 

gdb 

• Starten mit: gdb 

• Z.B. gdb ./first 

• Hilfe mit help 

• Starten des Programms im gdb: run 

• .... dann läuft das Programm normal ab 

• Um es an einer bestimmten Stelle anzuhalten, verwendet 

man Breakpoints (vor Starten mit run!): 

• setzen mit break *+offset 

- label = ein Label im Assembler Sourcecode 

- offset = Verschieben um offset Bytes 

• Auflisten aller Breakpoints mit info break 

• Löschen von Breakpoints mit delete 

- nummer=die Nummer des Breakpoints (bekommt man über info break) 



3-83 

Beispiel 

fischer@picard:~/cvs/lehre/info3/vorlesung/assembler$ gdb ./first 

GNU gdb 5.3 

Copyright 2002 Free Software Foundation, Inc. 

(gdb) break *asm_main 

Breakpoint 1 at 0x8048410 

(gdb) info break 

Num Type Disp Enb Address What 

1 breakpoint keep y 0x08048410 

(gdb) delete 1 

(gdb) info break 

No breakpoints or watchpoints. 

(gdb) 



3-84 

Weitere typische Kommandos 

• Wenn man einen Breakpoint mit break gesetzt hat und das 

Programm mit run gestartet hat, dann hält es bei Erreichen des 

Breakpoints an. 

• Nun kann man den Inhalt von Speicher und Registern 

betrachten: 

• Ausgabe von Registern: 

• Ausgabe einzelner Register und Speicherbereiche 

• Ausführen der nächsten Instruktion(en): 

• stepi 

• Ausführen der nächsten Instruktion(en), überspringen von 

Funktionsaufrufen: 

• nexti 

• Ausführen bis zum Ende einer Funktion: finish 

• Ausführen bis zum nächsten Breakpoint: continue 



3-85 

Fazit Debugger 

• Debugger sind SEHR! hilfreich 

• Man benötigt fast immer einen Debugger wenn man 

ernsthaft Software entwickelt 

• gdb ist etwas archaisch 

• Insbesondere bei Entwicklungsumgebungen unter 

Windows gibt es sehr komfortable Debugger 

• mit grafischer Oberfläche 

• Unter Unix ist ddd als Benutzeroberfläche für gdb zu 

empfehlen 

• für Assembler nicht ganz unproblematisch

Der Assembler - Universität zu Lübeck

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?