Wie Sie eine assembly-Sprache funktioniert?

Ich Lerne Montage und ich habe diesen Assembler-code, und mit viel Mühe ihn zu verstehen, kann jemand erläutern?

Dump of assembler code for function main:
0x080483ed <+0>:    push   ebp
0x080483ee <+1>:    mov    ebp,esp
0x080483f0 <+3>:    sub    esp,0x10
0x080483f3 <+6>:    mov    DWORD PTR [ebp-0x8],0x0
0x080483fa <+13>:   mov    eax,DWORD PTR [ebp-0x8]
0x080483fd <+16>:   add    eax,0x1
0x08048400 <+19>:   mov    DWORD PTR [ebp-0x4],eax
0x08048403 <+22>:   leave  
0x08048404 <+23>:   ret

Bis jetzt meine verstanden zu wissen, ist die folgende:

Drücken etwas (weiß nicht was) in ebp registrieren. dann verschieben Sie Inhalte von esp registrieren Sie sich in ebp (ich denke, die Daten von ebp überschrieben werden soll), dann subtrahieren 10 von der esp und speichern Sie es in den esp (Die Funktion 10 byte, Das reg wird nie wieder verwendet, also kein Punkt, dies zu tun-Betrieb). Nun weisen Sie den Wert 0 an die Adresse, die Spitzen von 8 bytes weniger als ebp.

Nun speichern Sie diese Adresse in register eax. Nun fügen Sie 1 auf den Wert hingewiesen, die von eax (der Vorherige Wert verloren). Nun speichern Sie die eax Wert auf [ebp-0x4], dann verlassen, um die Rückkehr-Adresse main.

Hier ist mein C-code für das obige Programm:

int main(){

int x=0;
int y = x+1;
}

Nun, kann jemand herausfinden, wenn ich falsch bin nichts,und ich versteh auch nicht, der mov at <+13> es addiert 1, um die addrs ebp-0x8, aber das ist die Adresse von int x so x nicht mehr 0 enthalten. Wo bin ich falsch?

Warum nicht abholen eine Anleitung zum Zusammenbau? push ebp nicht schieben etwas in ebp es wird der aktuelle ebp Inhalt auf dem Stapel, so dass Sie später wiederhergestellt werden.
Nehmen Sie ein Lesen Sie hier: en.wikibooks.org/wiki/X86_Disassembly/...

InformationsquelleAutor Tamim Addari | 2013-11-25

15

zunächst push ebp und dann mov ebp, esp sind zwei Anweisungen, die Häufig am Anfang einer Prozedur. ESP-register ist ein Indikator für die Spitze des stack - also es ändert sich ständig, wie der Stapel wächst oder schrumpft. EBP ist eine helfende registrieren Sie sich hier. Zuerst schieben wir Inhalt von ebp auf dem stack. dann kopieren wir ESP (aktuelle stack top Adresse) zu ebp - das ist, warum, wenn wir auf andere Elemente auf dem stack verwenden wir Konstanten Wert von ebp (und nicht das wechseln des esp).
```
 sub esp, 0x10 ; means we reserve 16 bytes on the stack (0x10 is 16 in hex) 
```
nun für den echten Spaß:
```
 mov    DWORD PTR [ebp-0x8],0x0 ; remember ebp was showing on the stack
                                ; top BEFORE reserving 16 bytes.
                                ; DWORD PTR means Double-word property which is 32 bits.
                                ; so the whole instruction means
                                ; "move 0 to the 32 bits of the stack in a place which 
                                ; starts with the adress ebp-8.
                                ; this is our`int x = 0`

 mov    eax,DWORD PTR [ebp-0x8] ; send x to EAX register.
 add    eax,0x1`                ; add 1 to the eax register
 mov    DWORD PTR [ebp-0x4],eax ; send the result (which is in eax) to the stack adress
                                ; [ebp-4]
 leave                          ; Cleanup stack (reverse the "mov ebp, esp" from above).
 ret                            ; let's say this instruction returns to the program, (it's slightly more
                                ; complicated than that)
```
Hoffe, das hilft! 🙂
- (0x10 is 32 in hex) Sind Sie sicher?
- Hier ist die zwei Frage, was ist der Gewinn von sub esp, 0x10 ,, dieser Befehl weder etwas, noch ist es später benötigt, und die zweite Frage ist, die Register enthalten nicht nur die Adresse.Es können Werte enthalten auch? wie in add eax,0x1 ?
- Bearbeitet ich, dass, natürlich, es ist 16 in hex. @TamimAdDari sub esp 0x10 verpasst die top-of-the-stack-pointer. Die grundlegende Regel, die Sie haben zu erinnern ist, dass "Der stack wächst in Richtung niedriger Adressen" - also durch Subtraktion 16 aus dem Stapel, den du eigentlich behalten 16 Byte auf dem stack (dies ermöglicht es Ihnen zu schreiben x und y gibt es zwei 32-bit-Sequenzen)
- ja, Registern können Werte enthalten. EAX zum Beispiel ist ein 32-bit-register - was bedeutet, es kann speichern von binären Darstellungen der zahlen bis 4 Milliarden. Mehr über Register hier: eecg.toronto.edu/~amza/www.mindsec.com/files/x86regs.html
- der stack-pointer angepasst wird, so dass Argumente an eine Funktion main() anrufen konnte, werden auf den stack geschoben, ohne es zu überschreiben/Kollision mit x und y. Sie sind richtig in der Beobachtung ist die nicht wirklich benötigt/verwendet. Einige Register sind speziell zum halten von Zeigern (z.B. "sp" steht für stack-pointer, während einige sind die Allgemeinen Zwecke und kann Daten enthalten oder Zeiger); einige Montage-Anweisungen ermöglichen die Verwendung von Daten, Zeiger und Zähler nur, wenn Sie im Register unterstützt.
- Dies bedeutet, dass diese Funktion nicht in der Lage, Zugriff auf einen Speicher über esp-10x, Also im Grunde esp ist die Unterseite des Stapels und ebp ist der stack-Spitze
- im Gegenteil: esp zeigt IMMER oben auf dem stack, und Sie gespeicherten ebp in der zweiten Zeile (top of stack niedriger sein wird in der Erinnerung als seine anderen Elemente, denn das ist die Art und Weise es entworfen wurde) und wenn Sie z.B. versuchen, auf die Adresse [esp - 10]- Sie bezieht sich auf die Erinnerung, die NICHT den stack mehr - es ist nur ein paar zufällige Speicher geben wird, zufällige Ergebnisse.
- die Funktion kann soviel Speicher verwenden wie es mag, aber nur 16 bytes reserviert waren hier für die lokalen Variablen. Die ebp, esp - pair ist keine Einschränkung per se, so kann der code-Adresse einen beliebigen Wert es will. Dabei wird normalerweise ein Puffer-überlauf-Fehler oder eine Beschädigung von stapeln wenn. So Ihr Verständnis, dass die Funktion kann nicht über esp-10x falsch ist und Sie sollten nicht denken, dass es als solche. Es SOLLTE nicht darüber hinaus.
InformationsquelleAutor Simon
5
```
0x080483ed <+0>:    push   ebp
0x080483ee <+1>:    mov    ebp,esp
```
Aufbau der Stapel-Rahmen. Speichern Sie die alte base pointer und legen Sie die oben auf dem Stapel, als der neue base-pointer. Dies ermöglicht es, dass lokale Variablen und Argumente innerhalb dieser Funktion verwiesen werden, die relativ zu ebp (base pointer). Dies hat den Vorteil, dass Ihr Wert stabil ist im Gegensatz zu esp, die betroffen ist durch pushes und pops.
```
0x080483f0 <+3>:    sub    esp,0x10
```
Auf der x86-Plattform der stack wächst nach unten. Im Allgemeinen bedeutet dies esp hat einen niedrigeren Wert (Adresse im Speicher) als ebp. Wenn ebp == esp hat der Stapel nicht reserviert Speicher für die lokalen Variablen. Dies bedeutet nicht, es ist "leer" - eine gemeinsame Nutzung des Stacks ist [ebp+0x8] zum Beispiel. In diesem Fall der code ist auf der Suche nach etwas auf dem stack, die vorher geschoben, auf die vor dem Aufruf (dies könnte man Argumente in der stdcall Konvention).

In diesem Fall wird der stack erweitert von 16 bytes. In diesem Fall wird mehr Speicherplatz reserviert wird als notwendig für Ausrichtung Zwecke:
```
0x080483f3 <+6>:    mov    DWORD PTR [ebp-0x8],0x0
```
Die 4 bytes an [ebp-0x8] initialisiert werden auf den Wert 0. Dies ist Ihre x lokale variable.
```
0x080483fa <+13>:   mov    eax,DWORD PTR [ebp-0x8]
```
Die 4 bytes an [ebp-0x8] verschoben werden, zu einem register. Arithmetische Befehle nicht bedienen können mit zwei speicheroperanden. Daten müssen bewegt werden, um eine sich zuerst registrieren, bevor die Arithmetik durchgeführt wird. eax enthält jetzt den Wert Ihres x variable.
```
0x080483fd <+16>:   add    eax,0x1
```
Den Wert eax ist erhöht, damit es hält nun den Wert x + 1.
```
0x08048400 <+19>:   mov    DWORD PTR [ebp-0x4],eax
```
Speichert den berechneten Wert zurück auf den stack. Beachten Sie die lokalen Variablen ist nun [ebp-0x4] - das ist Ihr y variable.
```
0x08048403 <+22>:   leave  
```
Zerstört den stack frame. Im wesentlichen maps für pop ebp und wieder der alte stack base pointer.
```
0x08048404 <+23>:   ret 
```
Erscheint der stack-Spitze, die Behandlung der Wert als eine Rückkehr-Adresse und setzt den Programm-Zeiger (eip) auf diesen Wert. Die Adresse zurück, die in der Regel enthält die Adresse der Anweisung, die direkt nach der call Unterricht brachte, dass die Ausführung in dieser Funktion.
- "In diesem Fall mehr Speicherplatz reserviert wird als notwendig für die Ausrichtung der Zwecke". Ah, das ist erhellend. Ich Frage mich, warum die Anzahl der bytes verwendet, die von einheimischen nicht immer addieren, um die Anzahl von bytes reserviert.
InformationsquelleAutor Mike Kwan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.