Inhaltsverzeichnis. 1 Einleitung 2

Inhaltsverzeichnis 1 Einleitung 2 2 Installation 3 2.1 Windows............................................. 3 2.1.1 Yasm per Konsole nutzen............................... 3 2.1.2 Integration mit Visual Studio............................ 4 2.2 Linux................................................ 6 2.3 Unterschied zwischen Linux und Windows........................ 7 3 Von C zu Assembler 8 4 Debugging 9 4.1 Windows............................................. 9 4.1.1 Funktionen debuggen................................. 12 4.2 Linux................................................ 13 4.2.1 Registerwerte ausgeben................................ 15 4.2.2 Funktionen debuggen................................. 16 4.2.3 Weitere Befehle..................................... 18 5 ObjectFiles 19 5.1 Windows............................................. 19 5.2 Linux................................................ 19 6 Inline Assembler 20 6.1 Windows............................................. 20 6.2 Linux................................................ 20 7 Nutzung der X87 FPU 21 8 Beschleunigung von Berechnungen mit SSE 22 9 Der Wechsel von 32 zu 64 Bit 23 10 Ausblick 24 11 Anhang 25 1

1 Einleitung 2

2 Installation 2.1 Windows Yasm kann als vorkompilierte Exe runtergeladen werden und kommt mit entsprechende Datein um yasm in Visual Studio einzubinden. Die entsprechende Archive sind unter http: //www.tortall.net/projects/yasm/wiki/download zu finden. Unter Windows gibt es 2 Möglichkeiten yasm zu benutzen, einmal wie unter Linux per Konsole oder indem man yasm in Visual Studio einbindet. Wir werden beide Wege beschreiben. 2.1.1 Yasm per Konsole nutzen Damit die folgende Befehle funktionieren muss die Yasm Exe entweder in der PATH Variable eingetragen sein oder in dem Ordner liegen in dem man kompilieren möchte. Wie üblich werden wir mit einem Hello World Programm den Einstieg in Assembler beginnen, hier der entsprechende Code:.data h e l l o :. s t r i n g " Hello World\n ". t e x t. g l o b l _main _main : pushl $ h e l l o c a l l _ p r i n t f subl $4,%esp c a l l _ e x i t Diese speichern wir als hello.asm und kompilieren sie mit Hilfe von Yasm zu einer Objectfile. >vsyasm. exe f win32 p gas h e l l o. asm Und nun nutzen wir den Linker der mit Visual Studio kommt um aus der Objectfile eine Anwendung zu generieren. Um Zugriff auf den Linker zu haben müssen wir die Visual Studio Variables laden, dies geht einfach indem man aus der Konsole mit der gelinkt werden soll vcvars32.bat aufruft, diese liegt in VC\bin Ordner im Visual Studio Verzeichnis. Danach kann man mit Hilfe des Linkers seine Anwendung wie folgt erzeugen. >l i n k h e l l o. obj subsystem : console d e f a u l t l i b : msvcrt Nun sollte in dem Ordner eine Hello.exe liegen die wenn man sie ausführt Hello World ausgibt und sich dann beendet. 3

2.1.2 Integration mit Visual Studio Nachdem wir das entsprechende Archive von der Webseite runtergeladen haben ist die Integration recht einfach, eine genau Anleitung liegt als txt-datei dabei. Als erstes müssen wir die Yasm Exe in den Bin Ordner von Visual Studio kopieren. Die restlichen Datein müssen in den Ordner Program Files\MSBuild\Microsoft.Cpp\v4.0\BuildCustomizations kopiert werden. Wenn wir nun ein neues Projekt erstellen müssen wir bei den Build Customizations vsyasm auswählen. Jetzt müssen wir in den Linkereinstellungen die zusätzlichen Kommandozeilenoption /DEFAULTLIB:MSVCRT eingetragen. 2.1 Windows 4

Auch müssen wir das Zielsystem einstellen in dem unsere Anwendung laufen soll, in unserem Fall die Konsole, damit werden die benötigten Bibliotheken zu unserer Anwendung gelinkt die wir brauchen um Text ausgeben zu können Außerdem stellen wir noch eine Yasm Option um, damit wir den Gnu Asembler Syntax kompilieren können. In den Projekteigentschaften sollte ein Menüpunkt für alle Yasmoptionen sein, dort stellen wir den Parser auf Gas um. 2.1 Windows 5

Jetzt können wir unser Hello.asm auch mit Visual Studio kompilieren. 2.2 Linux Die Installation unter Linux ist relativ einfach. Die meisten Distributionen enthalten schon den GCC sodass nur noch Yasm installiert werden muss. Dies sollte mit dem Packagemanager möglich sein. Unter Ubunutu kann man yasm mit Hilfe von apt-get wie folgt installieren: apt get i n s t a l l yasm Nun überprüfen wir noch ob auch alles korrekt funktioniert indem wir ein Hello World Programm in Assembler kompilieren..data h e l l o :. s t r i n g " Hello World\n ". t e x t. g l o b l main main : pushl $ h e l l o c a l l p r i n t f subl $4,%esp movl $1,%eax i n t $0x80 2.2 Linux 6

Wir speichern diesen Code nun in einer Datei mit dem Namen hello.asm. Als erstes nutzen wir yasm um den Assemblercode in eine Objectfile zu übersetzen und lassen dann GCC eine Anwendung mit Hilfe der Objectfile erstellen. yasm f e l f p gas mul. asm gcc melf_i386 o mul mul. o Danach können wir mit. hello unser Programm aufrufen und bekommen wie erwartet die Nachricht Hello World angezeigt. 2.3 Unterschied zwischen Linux und Windows Obwohl wir den gleichen Kompiler nutzen gibt es einige kleine aber wichtige Unterschiede zwischen Windos und Linux, die entstehen da wir auf Linux GCC nutzen um unsere Anwendung zu linken und auf Windows Visual Studio. So heisst das Label für den Einsprungspunkt auf Linux main und auf Windows _main. Auch beenden wir auf Linux unsere Anwendung mit dem Interupt 0x80 und unter Windows indem wir die Funktion _exit aufrufen. Nachfolgend werden wir immer die Linuxvariante nutzen, daher müssen Windowsnutzer daran denke auf die beiden Unterschiede zu achten, ansonst sind alle Beispiele auf beiden System laufähig. 2.3 Unterschied zwischen Linux und Windows 7

3 Von C zu Assembler 8

4 Debugging 4.1 Windows Um unser Programm debuggen zu können muss der Kompiler erst Debug Symbole erzeugen, ansonst kann der Visual Studio Debugger keine Breakpoints setzen und dort anhalten. Um Debug Symbole zu erzeugen müssen wir die Einstellung von Yasm ändern, in den Projekteigentschaften direkt in Yasm Assembler die Option Debug Information auf Yes setzen. Damit sind schon alle Vorbereitungen fürs Debugging abgeschloss, uns fehlt nur noch ein Stück Code zum debuggen. Als erstes werden wir ein Programm nehmen das allen Registern ein Wert zuweisst.. t e x t. g l o b l _main _main : movl $1,%eax movl $2,%ebx movl $3,%ecx movl $4,%edx movl $5,% e s i movl $6,% edi ret 9

Wenn wir nun mit der linken Maustaste auf den grauen Rand neben der ersten movl Instruktion klicken wird dort ein Breakpoint gesetzt, markeirt durch einen großen roten Punkt der neben der Zeile auftaucht. Wenn wir nun durhc drücken der F5 teste den Debugger starten sollte Visual Studio in die Debugansicht wechseln und ein kleiner gelber Pfeil links neben der Zeile markiert an welcher Stelle des Programmes wir uns gerade befinden. 4.1 Windows 10

Der nächste Schritt ist das Register Window zu öffnen damit wir den Wert alle CPU Register sehen können. Das Register Window öffnen wir indem wir auf Debug/Windows/Register klicken, damit öffnet sich unten ein neues Fenster das die Registerinhalt anzeigt. Durch drücken der F10 Tasten wird die Instruktion ausgeführt auf die der gelbe Pfeil zeigt und dieser wandert zur nächsten Instruktion. Bei jedem Schritt sehen wir im Registerfenster wie sich der Wert von zwei Registern ändernt, dies ist einmal EIP, der Instruktionpointer und einmal von dem Regist das gerade einen neuen Wert zugewissen bekommt, wenn der gelbe Pfeil am Funk- 4.1 Windows 11

tionaufruf von exit angekommen ist sollten die Register eax bis edi die Werte 1 bis 6 beinhalten. 4.1.1 Funktionen debuggen Nachdem wir nun schonmal Schritt für Schritt durch unser Programm laufen können, schauen wir uns nun an wie man Funktionen debuggen kann. Dafür brauchen wir erstmal ein neuen Code, dieser macht das gleiche wie der vorherige nur das das setzen der Register nun in einer Funktion ausgelagert und unsere Mainfunktion diese Funktion aufruft.. t e x t. g l o b l _main _main : c a l l c a l l func _ e x i t func : movl $1,%eax movl $2,%ebx movl $3,%ecx movl $4,%edx movl $5,% e s i movl $6,% edi ret Wir setzen den Breakpoint diesmal auf den Funktionsaufruf, wenn wir nun mit F10 ein Schritt im Programm weitergehen sehen wir im Register Window das nach dem Funktionsaufruf alle Register ihren entsprechende Wert haben, also wurde die Funktion komplett ausgeführt. Wir haben auch die Möglichkeit in eine Funktion zu springen, wenn wir dies wollen müssen wir statt F10 F11 drücken, damit teilen wir dem Debugger mit das er in die Funktion springen soll wenn die nächste Instruktion eine Funktionsaufruf ist. 4.1 Windows 12

In der Funktion können wir dann wieder mit F10 wie gewohnt durch das Program laufen. Eine interessante Beobachten ist das wenn wir den Stackpointer ansehen merken wir das wenn wir in die Funktion springen sich der Wert um 4 erniedrigt, dies liegt daran das call func die Rücksprungadresse auf den Stack pushed und die ist bei 32Bit Anwendung 4 Byte gross. 4.2 Linux Um unser Programm debuggen zu können muss Yasm uns Debugsymbole erzeugen, damit der Debugger weiss wie unser Program aufgebaut ist. Damit Debugsymbole erzeugt werden müssen wir nur einen weiteren Parameter hinzufügen, mit -g dwarf2 erzeugt yams Debugsymbole für den Gnu Debugger GDB. Wir speicher das folgende Program in einer debug.asm Datei.. t e x t. g l o b l main main : movl $1,%eax movl $2,%ebx movl $3,%ecx movl $4,%edx movl $5,% e s i movl $6,% edi movl $1,%eax i n t $0x80 Und kompilieren es mit yasm f e l f p gas g dwarf2 debug. asm 4.2 Linux 13

gcc melf_i386 o debug debug. o Nun starten wir den GDB und übergeben als Parameter unser Program. gdb debug Nun sollte etwas Text erscheinen der angibt welche GDB Version wir nutzen, das GDB unter der GPL V3 lizenziert ist und am Ende steht ein (gdb). Hier erwartet der GDB nun unsere Eingabe. Als erstes geben wir einfach run ein, damit das Program ausgeführt wird. GDB wird uns anzeigen welches Programm ausgeführt wird und danach das das Program mit dem Rückgabewert 01 beendet wurde, wir sehen keine Ausgabe da unser Programm keine hat. ( gdb ) run S t a r t i n g program : /nethome/ f i r e 0 1 / disc01 / users1 / f _ k e r g e r / p i d l /debug Program e x i t e d with code 02. Ein Program einfach im Debugger laufen zu lassen bringt erstmal keine Vorteile, aber in Kombination mit Breakpoints kann man den Programmfluss besser nachvollziehen und nachschauen was für Werte einzelne Register haben. Wenn der GDB nicht mehr läuft starten wir ihn wie gewohnt mit gdb debug Bevor wir nun mit run das Programm starten setzen wir ein Breakpoint am Anfang der Mainfunktion ( gdb ) break main Breakpoint 1 at 0x8048380 : f i l e debug. asm, l i n e 5. Wenn wir nicht am Anfang einer Funktion eine Breakpoint setzen wollen können wir auch eine Datei plus Zeilennummer angeben ( gdb ) break debug. asm:7 Breakpoint 2 at 0x8048399 : f i l e debug. asm, l i n e 7. Mit run wird nun das Program ausgeführt bis der GDB auf einen Breakpoint trifft, dann hält das Programm an und die nächste Zeile die ausgeführt werden soll wir ausgegeben, in unseren Beispiel also die erste Zeile der Mainfunktion ( gdb ) run S t a r t i n g program : /nethome/ f i r e 0 1 / disc01 / users1 / f _ k e r g e r / p i d l /debug Breakpoint 1, main () at debug. asm:5 5 movl $1,%eax Wenn wir nun c oder continue eingeben wird das Program bis zum nächsten Breakpoint ausgefürht ( gdb ) c Continuing. Breakpoint 2, main () at debug. asm:7 7 movl $3,% ecx 4.2 Linux 14

Wenn man nun von einer bestimmten Stelle aus analysieren will was ein Program macht ist es oft sinnvoll sich Zeile für Zeile anzeigen zu lassen welcher Befehl ausgeführt wird. Wurde ein Program an einem Breakpoint angehalten kann man per Eingabe von step oder s die aktuelle Zeile ausführen lassen und die nächste Zeile wird angezeigt. Breakpoint 2, main () at debug. asm:7 7 movl $3,% ecx 8 movl $4,%edx 9 movl $5,% e s i 10 movl $6,% edi 13 movl $1,%eax 14 i n t $0x80 Program e x i t e d with code 02. GDB merkt sich den letzten Befehl den wir ausgeführt haben, somit können wir im letzten Beispiel statt immer wieder s einzugeben einfach Enter drücken, damit wir unsere letzte Eingabe wiederholt, das gleiche gilt auch für step,c oder continue. 4.2.1 Registerwerte ausgeben GDB erlaubt uns auch die einzelnen Werte von Registern anzuschauen, dazu nutzen wir den print(oder in Kurzform einfach p) mit $(Registername) um uns den Wert im Register anzeigen zu lassen. Wir starten per run wieder unser Programm und unser Breakpoint hält wieder in der ersten Zeilen an, mit Hilfe des print Befehles sehen wir das $ecx zur Zeit den Wert 1 hat, nachdem wir den Move Befehl ausgeführt haben ist der wert in $ecx 3, das ist das Verhalten da wir erwartet haben. Diesen Vorgang wiederholen wir mit dem Register $edx, dabei sehen wir das das Register erst uninitialisiert ist und danach den Wert 4 enthält. Breakpoint 1, main () at debug. asm:7 7 movl $3,% ecx Current language : auto ; c u r r e n t l y asm ( gdb ) p $ecx $1 = 1 8 movl $4,%edx ( gdb ) p $ecx $2 = 3 ( gdb ) p $edx $3 = 1074854976 9 movl $5,% e s i 4.2 Linux 15

( gdb ) p $edx $4 = 4 Mit Hilfe des print Befehls können wir uns auch den Program Counter anzeigen lassen, dazu nehmen wir als Registername $pc. Dies gibt dann den Inhalt des Programcounter aus, also die Adresse im Speicher die als nächstes ausgeführt wird. 4.2.2 Funktionen debuggen Als nächstes wollen wir uns Anschauen wie man mit Funktionen in GDB arbeiten kann, dafür nutzen wir folgendes Programm als Beispiel.. t e x t. g l o b l main main : c a l l func movl $1,%eax i n t $0x80 func : movl $1,%eax movl $2,%ebx movl $3,%ecx movl $4,%edx movl $5,% e s i movl $6,% edi ret Ein Breakpoint wird auf den Anfang der main Funktion gesetzt und danach das Program gestartet, durch den Breakpoint hält das Programm beim Funktionsaufruf an, wenn wir nur mit Hilfe von step(kurz s) ein Schritt weiter im Program laufen landen wir in der Funktion. Nach 7 weiteren Schritten sind wir wieder aus der Funktion rausgesprungen und setzen den normalen Programmablauf fort. ( gdb ) break main Breakpoint 1 at 0x8048380 : f i l e debug.asm, l i n e 5. ( gdb ) run S t a r t i n g program : /nethome/ f i r e 0 1 / disc01 / users1 / f _ k e r g e r / p i d l /debug Breakpoint 1, main () at debug.asm :5 5 c a l l func Current language : auto ; c u r r e n t l y asm func () at debug.asm :12 12 movl $1,%eax 4.2 Linux 16

13 movl $2,%ebx 14 movl $3,%ecx 15 movl $4,%edx 16 movl $5,% e s i 17 movl $6,% edi 18 ret main () at debug.asm :8 8 movl $1,%eax 9 i n t $0x80 Program e x i t e d with code 02. Wenn wir beim debuggen nicht in einen Funktion springen wollen dürfen nicht step sondern next(kurz n) benutzen, damit wird die Funktion ausgeführt und der Debugger springt zur nächsten Zeile nach der Funktion. Mit Hilfe des print Befehls überprüfen wir noch das die Funktion auch wirklich ausgeführt wurde in dem wir uns den Wert von dem Register $eax anzeigen lassen. Breakpoint 1, main () at debug.asm :5 5 c a l l func Current language : auto ; c u r r e n t l y asm ( gdb ) n 8 movl $1,%eax ( gdb ) p $eax $1 = 1 Ist man doch einmal in eine Funktion gesteppt kann man mit Hilfe von finish aus der Funktion springen, das heißt die Funktion wir fertig ausgeführt und der Debugger hält an der nächsten Zeile auserhalb Funktion wieder an. Breakpoint 1, main () at debug.asm :5 5 c a l l func func () at debug.asm :12 12 movl $1,%eax ( gdb ) f i n i s h Run t i l l e x i t from #0 func () at debug.asm :12 main () at debug.asm :8 8 movl $1,%eax 4.2 Linux 17

4.2.3 Weitere Befehle Der Befehl where gibt die aktuelle Zeile und Position im Program an, nutz man den Befehl innerhalb einer Funktion wird auch die Zeile des Funktionsaufrufes mit ausgegeben. ( gdb ) where #0 fun c () a t debug.asm :12 #1 0x08048385 in main () a t debug.asm : 5 Mit quit kann man jederzeit den Debugger verlassen, sollte das Programm dabei noch laufen fragt der Debugger nach ob man ihn wirklich beenden will, die kann man mit y bestätigen. 4.2 Linux 18

5 ObjectFiles 5.1 Windows ObjectFiles unter Windows 5.2 Linux ObjectFiles unter Linux 19

6 Inline Assembler 6.1 Windows Inline Asm unter Windows 6.2 Linux Inline Asm unter Linux 20

7 Nutzung der X87 FPU 21

8 Beschleunigung von Berechnungen mit SSE 22

9 Der Wechsel von 32 zu 64 Bit 23

10 Ausblick 24

11 Anhang 25