"Hello World!" im Debugger [prontosystems.org]

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
[[:tux|{{ :linux.png?40|}}]]
===== "Hello World!" im Debugger =====

Das Debuggen eines Programms gehört sicherlich zu den anspruchsvollsten Angelegenheiten, kann aber unter gegebenen Umständen äußerst nützlich sein. 


==== Der Quellcode ====

Das folgende in C geschriebene Programm wird bei der Ausführung 10x die Zeile >><fc #008000>Hello, World!</fc><< auf der Standardausgabe anzeigen:

<code c|~/firstprog.c>#include <stdio.h>

int main()
{
  int i;
  for(i=0; i < 10; i++)
  {
    printf("Hello, World!\n");
  }
  return 0;
}</code> 

Kompiliert man diesen Code mit der Option >><fc #008000>-g</fc><< werden Debug-Informationen in Form des Quellcodes mit in die binäre Datei einkompiliert, um eine spätere Analyse zu erleichtern: 
<xterm>$ <fc #008000>gcc -g ~/firstprog.c</fc></xterm>Ohne Angabe einer Ausgabedatei (>><fc #008000>-o //output_file//</fc><<) wird daraus das binäre Programm >><fc #008000>a.out</fc><<:
<xterm>$ <fc #008000>~/a.out</fc> 
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!</xterm>

==== Disassemble Binary ====
Mit dem Debugger >><fc #008000>gdb</fc><< lässt sich nun dieses Programm untersuchen:

<xterm>$ <fc #008000>gdb -q ./a.out</fc> 
Reading symbols from /home/pronto/booksrc/a.out...done.
<fc #800000>(gdb)</fc> <fc #008000>list</fc>
1	#include <stdio.h>
2	
3	int main()
4	{
5	  int i;
6	  for(i=0; i < 10; i++)
7	  {
8	    printf("Hello World!\n");
9	  }
10	}</xterm>

<xterm><fc #800000>(gdb)</fc> <fc #008000>disassemble main</fc>
Dump of assembler code for function main:
   //0x080483b4 <+0>:	push   ebp
   0x080483b5 <+1>:	mov    ebp,esp
   0x080483b7 <+3>:	and    esp,0xfffffff0
   0x080483ba <+6>:	sub    esp,0x20//
⇒  <fc #0000FF>0x080483bd <+9>:	mov    DWORD PTR [esp+0x1c],0x0</fc>
   0x080483c5 <+17>:	jmp    0x80483d8 <main+36>
   0x080483c7 <+19>:	mov    DWORD PTR [esp],0x80484b0
   0x080483ce <+26>:	call   0x80482f0 <puts@plt>
   0x080483d3 <+31>:	add    DWORD PTR [esp+0x1c],0x1
   0x080483d8 <+36>:	cmp    DWORD PTR [esp+0x1c],0x9
   0x080483dd <+41>:	jle    0x80483c7 <main+19>
   0x080483df <+43>:	leave  
   0x080483e0 <+44>:	ret    
End of assembler dump.</xterm>

<xterm><fc #800000>(gdb)</fc> <fc #008000>break main</fc>
Breakpoint 1 at 0x80483bd: file firstprog.c, line 6.</xterm>

<xterm><fc #800000>(gdb)</fc> <fc #008000>run</fc>
Starting program: /home/pronto/booksrc/a.out 

Breakpoint 1, main () at firstprog.c:6
6	  <fc #FF0000>for(i=0; i < 10; i++)</fc></xterm>

<xterm><fc #800000>(gdb)</fc> <fc #008000>i r $eip</fc>
eip            0x80483bd	<fc #0000FF>0x80483bd <main+9></fc></xterm>

Die og Kommandos nach dem gdb-Prompt >><fc #008000>(gdb)</fc><< haben folgende Bedeutung:

  * >><fc #008000>list</fc><<: Gibt den mit der Option >>-g<< einkompilierten Quellcode wieder.

  * >><fc #008000>disassemble main</fc><<: Disassemblierung der <fc #008000>main()</fc> Funktion. Hier wird die <fc #008000>main()</fc> Funktion in der Maschinensprache des vorliegenden Prozessors ausgegeben, wobei >>gdb<< hier auf die Intel Syntax eingestellt wurde (>><fc #008000>set disassembly-flavor intel</fc><<)

  * >><fc #008000>break main</fc><<: Damit wird der Debugger angewiesen an einem bestimmten Punkt (hier >><fc #008000>main</fc><<) anzuhalten.

  * >><fc #008000>run</fc><<: das eigentliche Programm wird gestartet, wobei der Haltepunkt am Anfang der <fc #008000>main()</fc> Fuktion den Debugger schon zum Stehen bringt, noch bevor irgendwelche Anweisungen der <fc #008000>main()</fc> Funktion ausgeführt werden.

  * >><fc #008000>i r $eip</fc><<: (Auch >><fc #008000>info register $eip</fc>) Damit der Prozessor ein Programm ausführt, muss sein Befehlszeiger auf den Anfang des Programms zeigen, also die Adresse der ersten Maschinencodeanweisung in das spezielle Register Befehlszeiger (<fc #008000>instruction pointer eip</fc>) geladen werden. Der Prozessor wird dann den auf diese Weise bezeichneten Befehl ausführen und im Normalfall anschließend den Inhalt des Befehlszeigers um die Länge des Befehls im Speicher erhöhen, so dass er auf die nächste Maschinenanweisung zeigt. Bei einem Sprungbefehl wird der Befehlszeiger nicht um die Länge des Befehls, sondern um die angegebene relative Zieladresse erhöht oder erniedrigt. Das Kommando >><fc #008000>i r $eip</fc><< zeigt auf diese Adresse (Blau dargestellt).

Der Programmablauf steht demnach aktuell bei Initialisierung der for-Schleife <fc #FF0000>for(i=0; i < 10;i++)</fc> und das Befehlszeiger Register zeigt auf <fc #0000FF>0x080483bd <+9></fc> in dem folgender Maschinenbefehl steht: 

''<fc #0000FF>mov    DWORD PTR [esp+0x1c],0x0</fc>''

Diese Assembler-Instuktion bewegt den Wert >><fc #008000>0</fc><< ([esp+0x1c],<fc #0000FF>0x0</fc>) in die um >><fc #008000>0x1c</fc><< erhöhte Speicheradresse ([esp<fc #0000FF>+0x1c</fc>],0x0), die im ESP-Register steht ([<fc #0000FF>esp</fc>+0x1c],0x0). Das ist die Stelle, an der die C-Variable >><fc #008000>i</fc><< im Speicher abgelegt ist. >><fc #008000>i</fc><< wird als Integerwert deklariert, der bei x86 Prozessoren 4 Byte im Speicher belegt. Lässt man sich den Inhalt dieser Adresse nun anzeigen, wird ein zufälliger Inhalt ausgegeben, weil der Programmablauf noch vor der Zuweisung der Variable >><fc #008000>i</fc><< steht:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/4xb $esp + 0x1c</fc>
<fc #FF00FF>0xbffff6fc</fc>:	<fc #0000FF>0xf4	0xbf	0x28	0x00</fc></xterm>

Dieses Kommando zählt zu der in >><fc #008000>$esp</fc><< gespeicherten Adresse >><fc #008000>0x1c</fc><< Adressen hinzu, was die Adresse >><fc #008000>0xbffff6fc</fc><< ergibt und zeigt den Inhalt dieser Adresse (>><fc #0000FF>0xf4	0xbf	0x28	0x00</fc><<) in vier hexadezimal dargestellten Byte >><fc #008000>4xb</fc><< an. Das vorangestellte >><fc #008000>x</fc><< bedeutet in diesem Kommando >><fc #008000>examine</fc><< (untersuche). Um die weitere Analyse dieser Adresse zu vereinfachen, kann diese auch in eine Variable gespeichert werden:

<xterm><fc #800000>(gdb)</fc> <fc #008000>print $esp + 0x1c</fc>
<fc #FF00FF>$1</fc> = (void *) <fc #FF00FF>0xbffff6fc</fc></xterm>

Noch immer aber steht der Programmablauf noch vor dem Ausführen der ersten Instruktion, diese kann jetzt mit dem >><fc #008000>nexti</fc><< (next instruction) Kommando ausgeführt werden:

<xterm><fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483c5	6	  <fc #FF0000>for(i=0; i < 10; i++)</fc></xterm>

Das Auslesen der Speichersdresse >><fc #FF00FF>0xbffff6fc</fc><< ergibt jetzt erwartungsgemäß >><fc #0000FF>0x00</fc><<, weil jetzt die Instruktion >><fc #FF0000>i=0</fc><< durchgeführt wurde:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/4xb $1</fc>
<fc #FF00FF>0xbffff6fc</fc>:	<fc #0000FF>0x00	0x00	0x00	0x00</fc></xterm>

''<fc #0000FF>jmp   0x80483d8 <main+36></fc>''

Der Befehlszeiger ist nun auf die nächste Adresse gesprungen und zeigt jetzt auf die Adresse >><fc #FF00FF>0x80483c5</fc><<, welche jedoch nur eine //Jump//-Instruktion >>jmp<< auf die Adresse >><fc #FF00FF>0x80483d8</fc><< ist.

<xterm><fc #800000><fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
=> <fc #0000FF>0x80483c5 <main+17>:	jmp   0x80483d8 <main+36></fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
<fc #FF00FF>0x080483d8</fc>	6	  for(i=0; i < 10; i++)</xterm>

Danach rückt EIP weiter zur nächsten Instruktion, wobei die folgenden Instruktionen am besten im Zusammenhang erklärt werden. 

=== if-then-else ===

Die erste Instruktion >><fc #008000>cmp</fc><< ist eine Vergleichsinstruktion, die den von der C-Variablen >><fc #008000>i</fc><< verwendeten Speicher mit dem Wert >><fc #008000>0x9</fc><< vergleicht.

''<fc #0000FF>0x080483d8 <+36>:	cmp    DWORD PTR [esp+0x1c],0x9</fc>''

Die nächste Instruktion >><fc #008000>jle</fc><< steht für //Jump if less than or euqal to// (>>springe bei kleiner oder gleich zu<<). Sie verwendet das Ergebnis des vorangegangenen Vergleichs, welcher im EFLAGS-Register gespeichert wird, um EIP auf einen anderen Teil des Codes zeigen zu lassen, wenn das Ziel der Vergleichsoperation kleiner oder gleich der Quelle ist. In diesem Fall besagt die Instruktion, dass an die Adresse >><fc #FF00FF>0x80483c7</fc><< gesprungen werden soll, wenn der Wert für die variable >><fc #008000>i</fc><< kleiner, gleich 9 ist. 

''<fc #0000FF>0x080483dd <+41>:	jle</fc>    <fc #FF00FF>0x80483c7</fc> <fc #0000FF><main+19></fc>''

Ist das nicht der Fall, wird EIP zur nächsten Adresse >><fc #FF00FF>0x080483df</fc><< geschickt, welche in unserm Fall eine >>leave<< (verlassen) Instruktion beinhaltet.

''<fc #FF00FF>0x080483df</fc> <fc #0000FF><+43>: leave</fc>''

Die Kombination dieser drei Instruktionen ergibt eine //if-then-else//-Kontrollstruktur: //Wenn >>i<< kleiner oder gleich 9 ist, springe zur Adresse an >><fc #FF00FF>0x80483c7</fc><<, andernfalls springe eine Instruktion weiter zur Adresse >><fc #FF00FF>0x080483df</fc><<.//

Da wir wissen, dass der Wert in dem Speicher abgelegt wird, der mit dem Wert 9 verglichen wird und da wir wissen, dass 0 kleiner oder gleich 9 ist, sollte EIP bei >><fc #FF00FF>0x80483c7</fc><< liegen, nachdem diese beiden Instruktionen ausgeführt wurden:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483d8 <main+36>:	cmp    DWORD PTR [esp+0x1c],0x9</fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483dd	6	  for(i=0; i < 10; i++)
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483dd <main+41>:	jle    0x80483c7 <main+19></fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
8	    printf("Hello World!\n");
<fc #800000>(gdb)</fc> <fc #008000>x/2i $eip</fc>
=> <fc #FF00FF>0x80483c7</fc> <main+19>:	<fc #0000FF>mov    DWORD PTR [esp],</fc><fc #FF00FF>0x80484b0</fc>
=> <fc #FF00FF>0x80483ce</fc> <main+26>:	<fc #0000FF>call   0x80482f0 <puts@plt></fc>
<fc #800000>(gdb)</fc></xterm>

Erwartungsgemäß haben diese beiden vorausgegangenen Instruktionen die Programmausführung an >><fc #FF00FF>0x80483c7</fc><< springen lassen, was uns zu den nächsten zwei Instruktionen >><fc #0000FF>mov</fc><< und >><fc #0000FF>call</fc><< führt. Die erste >>mov<<-Instruktion schreibt die Adresse >>0x80484b0<< in die Adresse, welche im ESP-Register enthalten ist. Das ESP-Regsiter ist derzeit folgendermaßen belegt:

<xterm><fc #800000>(gdb)</fc> <fc #008000>i r esp</fc>
esp            0xbffff6e0	0xbffff6e0</xterm>

Nicht weiter von Belang aber die mov-Instruktion möchte die Adresse >><fc #FF00FF>0x80484b0</fc><< dort hin schreiben. Aber warum? Was ist so besonders an der Speicheradresse >><fc #FF00FF>0x80484b0</fc><<? Finden wir es raus und lassen wir uns mal die ersten 8 Byte dieser Adresse anzeigen:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/8xb 0x80484b0</fc>
<fc #FF00FF>0x80484b0</fc>:	0x48	0x65	0x6c	0x6c	0x6f	0x20	0x57	0x6f</xterm>

Mit etwas Fantasie kommt man darauf, dass die Byte-Werte im Bereich der druckbaren ASCII-Zeichen liegen und hier nun unser Text >>Hello, World!<< gelandet sein könnte. GDB kann bei Zweifeln aber auch mit der Format-Option >><fc #008000>c</fc><< automatisch in der ASCII-Tabelle nachschlagen:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/8**c**b 0x80484b0</fc>
<fc #FF00FF>0x80484b0</fc>:	72 'H'	101 'e'	108 'l'	108 'l'	111 'o'	32 ' '	87 'W'	111 'o'</xterm> 

Die Format-Option >><fc #008000>s</fc><< gibt dann den gesamten String aus, der sich dahinter verbirgt:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/s 0x80484b0</fc>
<fc #FF00FF>0x80484b0</fc>:	 "Hello World!"</xterm>

Damit wissen wir nun, dass das Argument der >><fc #0000FF>printf()</fc><< Funktion, nämlich der String >><fc #0000FF>"Hello World!"</fc><< an der Adresse >><fc #FF00FF>0x80484b0</fc><< gespeichert ist und diese Adresse in die in ESP gespeicherte Adresse >><fc #FF00FF>0xbffff6e0</fc><< mit der >><fc #008000>mov</fc><<-Instruktion übertragen wird. Führen wir die >><fc #008000>mov</fc><<-Instruktion aus und lassen wir uns dann den Inhalt der an ESP gespeicherten Adresse anzeigen:

<xterm><fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483ce	8	    <fc #0000FF>printf("Hello World!\n")</fc>;
(gdb) x/xw $esp
<fc #FF00FF>0xbffff6e0</fc>:	<fc #FF00FF>0x080484b0</fc></xterm>

Erwartungsgemäß ist der Inhalt der Adresse >><fc #FF00FF>0xbffff6e0</fc><< nun die Adresse >><fc #FF00FF>0x080484b0</fc><<, in welcher unser String >><fc #0000FF>"Hello World!"</fc><< gespeichert ist.

Der Befehlszeiger >><fc #008000>EIP</fc><< steht danach an Adresse >><fc #FF00FF>0x80483ce</fc><<, in welcher eine >><fc #008000>call</fc><<-Instruktion gespeichert ist:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
=> <fc #FF00FF>0x80483ce</fc> <main+26>:	call   0x80482f0 <puts@plt></xterm>

An dieser Stelle erfolgt der eigentliche Aufruf der <fc #008000>printf()</fc>-Funktion, welche den Datenstring <fc #0000FF>"Hello World!"</fc> ausgibt:

<xterm><fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
<fc #0000FF>Hello World!</fc>
6	  for(i=0; i < 10; i++)</xterm>

Der Befehlszeiger ist zur nächsten Adresse >><fc #FF00FF>0x80483d3</fc><< gesprungen, in welcher eine >><fc #0000FF>add</fc><<-Instruktion gespeichert ist:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
=> <fc #FF00FF>0x80483d3</fc> <main+31>:	<fc #0000FF>add    DWORD PTR [esp+0x1c],0x1</fc></xterm>

Hier wird der Wert >><fc #0000FF>0x1</fc><< zu dem uns bereits bekannten Wert >><fc #0000FF>0x0</fc><< in Adresse >><fc #0000FF>[esp+0x1c]</fc><< addiert. Somit wird die letzte Anweisung in der >><fc #FF0000>for()</fc><<-Schleife -> >><fc #FF0000>i++</fc><< ausgeführt und der Wert >><fc #FF0000>i</fc><< um >><fc #FF0000>1</fc><< inkrementiert:

<xterm><fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483d8	6	  <fc #FF0000>for(i=0; i < 10; i++)</fc>
<fc #800000>(gdb)</fc> <fc #008000>x/4xb $esp + 0x1c</fc>
0xbffff6fc:	<fc #0000FF>0x01</fc>	0x00	0x00	0x00</xterm>

Der erste Durchlauf der >><fc #FF0000>for()</fc><<-Schleife ist nun abgeschlossen und der Befehlszeiger springt zur nächsten Adresse, welche wieder die >><fc #0000FF>cmp</fc><<-Instruktion enthält und einen neuen Durchlauf der >><fc #FF0000>for()</fc><<-Schleife anstößt. Dieses ganze Prozedere wiederholt sich nun solange, wie der Wert >><fc #FF0000>i</fc><< in Adresse >><fc #FF00FF>$esp + 0x1c</fc><< ≤ <fc #FF0000>9</fc> ist.

<xterm><fc #800000>(gdb</fc>) <fc #008000>x/2i $eip</fc>
=> 0x80483d8 <main+36>:	<fc #0000FF>cmp    DWORD PTR [esp+0x1c],0x9</fc>
   0x80483dd <main+41>:	jle    0x80483c7 <main+19></xterm>
   
Hier folgt nun der zweite Durchlauf der for()-Schleife im Zusammenhang. Die kursiv gestellte >>cmp<<-Instruktion repräsentiert dann bereits den übernächsten Durchlauf der for()-Schleife:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483d8 <main+36>:	cmp    DWORD PTR [esp+0x1c],0x9</fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483dd	6	  for(i=0; i < 10; i++)
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483dd <main+41>:	jle    0x80483c7 <main+19></fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
8	    printf("Hello World!\n");
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483c7 <main+19>:	mov    DWORD PTR [esp],0x80484b0</fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483ce	8	    printf("Hello World!\n");
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483ce <main+26>:	call   0x80482f0 <puts@plt></fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
Hello World!
6	  for(i=0; i < 10; i++)
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
<fc #0000FF>=> 0x80483d3 <main+31>:	add    DWORD PTR [esp+0x1c],0x1</fc>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
0x080483d8	6	  for(i=0; i < 10; i++)
<fc #800000>(gdb)</fc> <fc #008000>x/4xb $esp + 0x1c</fc>
0xbffff6fc:	0x02	0x00	0x00	0x00
//<fc #808080>(gdb)x/i $eip
=> 0x80483d8 <main+36>:	cmp    DWORD PTR [esp+0x1c],0x9
(gdb)</fc>//</xterm>

Schauen wir uns nun noch einmal das gesamte Disassembling an, kann der Verlauf der Schleife bzw. der gesamte Programmverlauf nachvollzogen werden:

<xterm><fc #800000>(gdb)</fc> <fc #008000>disassemble main</fc>
Dump of assembler code for function main:
   //0x080483b4 <+0>:	push   ebp
   0x080483b5 <+1>:	mov    ebp,esp
   0x080483b7 <+3>:	and    esp,0xfffffff0
   0x080483ba <+6>:	sub    esp,0x20//
   <fc #008080>0x080483bd <+9>:	mov    DWORD PTR [esp+0x1c],0x0</fc>
   <fc #FF00FF>0x080483c5 <+17>:	jmp    0x80483d8 <main+36></fc>
 ⇓ <fc #0000FF>0x080483c7 <+19>:	mov    DWORD PTR [esp],0x80484b0
   0x080483ce <+26>:	call   0x80482f0 <puts@plt>
   0x080483d3 <+31>:	add    DWORD PTR [esp+0x1c],0x1
   0x080483d8 <+36>:	cmp    DWORD PTR [esp+0x1c],0x9
   0x080483dd <+41>:	jle    0x80483c7 <main+19></fc>
   0x080483df <+43>:	leave  
   0x080483e0 <+44>:	ret    
End of assembler dump.</xterm>

Die dunklegrün markierte Zeile mit der ersten >><fc #008080>mov</fc><<-Instruktion initialisiert die Variable >><fc #008080>i</fc><< und belegt diese mit >><fc #008080>0x0</fc><<, die pink markierte Zeile mit der >><fc #FF00FF>jmp</fc><<-Instruktion springt in die Schleife zur >><fc #0000FF>cmp</fc><<-Instruktion und die blau markierten Zeilen repräsentieren die eigentliche >><fc #FF0000>for()</fc><<-Schleife in dem zuerst verglichen wird >><fc #0000FF>cmp</fc><< und solange das Ergebnis dieses Vergleichs ≤ 9 ist >><fc #0000FF>jle</fc><< der Instruktion Pointer >>EIP<< zur zweiten >><fc #0000FF>mov</fc><<-Instruktion springt, wo die Adresse >>0x80484b0<< in >>ESP<< geschrieben wird (Wir erinnern uns, in dieser Adresse ist der String >>"Hello World!<< gespeichert), danach springt >>EIP<< weiter an die nächste Adresse mit der >><fc #0000FF>call</fc><<-Instruktion, welche den in ESP gespeicherten String >>"Hello World!"<< ausgibt. >>EIP<< springt nun weiter zu >><fc #0000FF>add</fc><<-Instruktion, wo >><fc #0000FF>0x1</fc><< zu der Adresse >>[esp+0x1c]<< hinzu addiert wird und der Vergleich dieser Adresse mit ≤ 9 wird erneut durchgeführt.

Der Vollständigkeit wegen sollte noch gezeigt werden, dass die Schleife auch wie vorgesehen verlassen (>><fc #0000FF>leave</fc><<) wird, wenn die Variable >>i<< den Wert >><fc #FF0000>0xa</fc><< (10<sub>10</sub>) erreicht hat:

<xterm><fc #800000>(gdb)</fc> <fc #008000>x/4xb $esp + 0x1c</fc>
0xbffff6fc:	<fc #FF0000>0x0a</fc>	0x00	0x00	0x00
(gdb) x/i $eip
=> 0x80483d8 <main+36>:	cmp    DWORD PTR [esp+0x1c],0x9
<fc #800000>(gdb)</fc> nexti
0x080483dd	6	  for(i=0; i < 10; i++)
<fc #800000>(gdb)</fc> <fc #008000>x/i $eip</fc>
=> 0x80483dd <main+41>:	jle    0x80483c7 <main+19>
<fc #800000>(gdb)</fc> <fc #008000>nexti</fc>
<fc #0000FF>10	}</fc>
<fc #800000>(gdb)</fc> x/i $eip
=> 0x80483df <main+43>:	<fc #0000FF>leave</fc>  
<fc #800000>(gdb)</fc></xterm>

Mächtig viel Zenober für ein Programm, welches in gerade mal 2 Millisekunden vom Prozessor ausgeführt wird. Ich habe ein ganzes Wochenende mit diesem Artikel verbracht, habe aber viel dabei gelernt ;-)

<xterm>$ <fc #008000>time ./a.out</fc> 
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

real	0m0.002s
user	0m0.000s
sys	0m0.000s</xterm>

 --- //pronto 2011/10/09 15:21//