NASM startklar machen

NASM startklar machen
Wir verwenden für die Übungen NASM unter 64-bit-Linux. Dazu stelle ich drei Wege vor: einmal
am Poolrechner, einmal mit Remote-Zugriff auf einen Poolrechner und einmal mit Linux in einer
Virtual Box.
Im Anschluss erkläre ich wie man mit NASM umgeht.
Der "Poolrechner"-Weg
Im Raum K38 sind Rechner mit 64-bit-Linux und NASM installiert. Hier könnt ihr euch einfach
anmelden und loslegen. Macht weiter mit dem Abschnitt "NASM verwenden".
Der "Remote"-Weg
Für diesen Weg benötigt ihr einen SSH-Client. Unter Windows könnt ihr Putty verwenden. Wenn
ihr in der Konsole arbeiten wollt, reicht der SSH-Client aus. Falls ihr eine grafische
Benutzeroberfläche bevorzugt, arbeitet dieses Tutorial auch durch.
Loggt euch mit eurem SSH-Client auf einen Rechner in K38 ein, z.B. "peking.imp.fu-berlin.de".
Ihr werdet bei Putty dann gefragt, ob ihr dem Host vertraut. Klick dann auf "Ja". Als nächstes müsst
ihr euch mit euren Zedat-Namen und -Passwort anmelden. Nun könnt ihr wie in der Konsole auf
dem Rechner arbeiten.
Um Dateien in der Konsole zu bearbeiten (z.B. Assembler-Quelltexte), arbeitet euch in "pico",
"nano" oder "vim" ein. Falls ihr einen X-Server (wie Xming im verwiesenen Tutorial) benutzt,
könnt ihr einfach "gedit&" eintippen und ein Text-Editor erscheint bei euch lokal auf dem Monitor.
Ab hier könnt ihr mit dem Abschnitt "NASM verwenden" fortfahren.

Der "Virtual Box"-Weg
Bei diesem Weg müsst ihr Virtual Box auf eurem System installieren und in die Virtual Box
installiert ihr 64-bit-Ubuntu. Eine Anleitung für Windows ist hier zu finden. Das Tutorial ist nicht
aktuell, aber im Prinzip muss man nur immer auf "Weiter" klicken. Die wichtigsten Optionen sind
der Speicherort und die Größe der virtuellen Festplatte.
Im Tutorial ist ein weiteres Tutorial vorhanden, das erklärt wie man Ubuntu installiert. Ein weiteres
ist hier zu finden.
Wenn Ubuntu installiert ist, fehlt nur noch NASM. Um NASM zu installieren, öffnet die Konsole
(Terminal) und gebt folgendes ein:
> sudo apt-get install nasm
Bestätigt den Installationswunsch mit eurem Passwort, was ihr bei der Installation gewählt habt.
Danach wird NASM installiert und ihr könnt mit dem Abschnitt "NASM verwenden" fortfahren.
NASM verwenden
Testlauf
Um festzustellen, ob alles funktioniert wie es funktionieren sollte, haben wir ein paar Test-Dateien
für euch zur Verfügung gestellt. Man kann sie hier oder wie folgt mittels Konsole runterladen:
> wget http://page.mi.fu-berlin.de/markrudo/ti2/nasm_test.zip
Zum Entpacken und Ausführen führt bitte folgende Befehle aus:
> unzip nasm_test.zip

Archive: nasm_test.zip
creating: nasm_test/
inflating: nasm_test/foo.asm
inflating: nasm_test/Makefile
inflating: nasm_test/hello.asm
inflating: nasm_test/bar.c
> cd nasm_test
> make
> ./foo
Hello, world!
> ./hello
Test Here!
Hello from Assembly!
Wenn alles so ausgegeben wird wie hier angegeben, war der Test erfolgreich.
Allgemeiner Ablauf
Allgemein befolgt man fünf Schritte: Assembler-Quellcode schreiben, Quellcode zu einer Objekt-
Datei kompilieren, Objekt-Dateien zu einer Ausführbaren linken, Ausführbare starten bzw.
Ausführbare debuggen.
Quellcode schreiben
Als Beispiel sei hier "Hello World!" gegeben. Wir speichern die Datei als "hello_world.asm".
section .data
msg: db "Hello, world!", 10
.len: equ $ - msg ; Länge des Strings
section .text
global main
main:
mov
mov
mov
mov
int
eax, 4 ; write
ebx, 1 ; stdout
ecx, msg
edx, msg.len
0x80
mov eax, 1 ; exit
mov ebx, 0
int 0x80
Quellcode kompilieren
Zur Kompilierung reicht folgender Befehl aus:
> nasm -f elf64 hello_world.asm
Dabei gibt -f das Ausgabeformat an - in diesem Fall das 64-bit-ELF-Format für Linux.
Nach Ausführung dieses Befehls sollte eine Objekt-Datei "hello_world.o" erzeugt worden sein.
Wenn ihr zusätzlich ein Listing ausgegeben haben wollt, dann gebt noch die -l Option an.
> nasm -f elf64 -l hello_world.lst hello_world.asm

Objekt-Dateien linken
Die in NASM erzeugten Objektdateien können Verweise zueinander enthalten. Beispiel: Datei
A.asm ruft Label xyz auf, Label xyz wurde aber in Datei B.asm definiert. Dann enthält A.asm einen
Verweis nach B.asm, welcher vom sogenannten Linker aufgelöst werden muss.
Der Linker übernimmt im allgemeinen die Aufgabe mehrere Programmmodule (Objekt-Dateien) zu
einer ausführbaren Datei zu binden.
Um Den Linker auf unsere Objekt-Datei anzuwenden, gebt einfach folgendes in der Konsole ein:
> gcc -o hello_world hello_world.o
Dabei wird eine Ausführbare "hello_world" erstellt (-o Option).
Ausführbare starten
Um die Ausführbare zu starten einfach folgendes eingeben:
> ./hello_world
Ausführbare debuggen
Um die Ausführbare zu debuggen, ruft man den GNU Debugger mit der Ausführbaren als
Parameter auf:
>gdb hello_world
In GDB kann man dann Breakpoints bei den verwendeten Labels setzen mit:
gdb> break label
Um eure Anwendung zu starten, einfach den RUN-Befehl eingeben. Der Debugger wird beim
ersten Label stoppen, das ihr als Breakpoint gesetzt habt.
gdb> run
Um zu sehen wo ihr euch grad befindet, gebt folgendes ein:
gdb> disassemble
Es wird der Maschinen-Code für das aktuelle Unterprogramm ausgegeben (das Label unter dem ihr
euch befindet). Ein Pfeil (=>) zeigt eure aktuelle Position im Code.
Wenn ihr die aktuelle Belegung der Register wissen wollt, gebt "info registers" ein.
Mit "nexti" veranlasst ihr den Debugger genau eine Instruktion fortzuschreiten.
Mehr Tricks sind hier nachzulesen.

Weitere Links
Hier findet ihr ein Foliensatz zu Adressierungsarten.
Hier findet ihr eine Befehlsreferenz zu x86.
NASM Dokumentation.