Nachrichten

1

Softwareentwicklung / Re: NASM: C-Funktion mit Parametern aufrufen

« am: 09. February 2013, 14:13 »

Okay. Vielen Dank!
Ich glaube jz habe ich es endlich auch begriffen!

BTW: Du hast momentan 1337 Forumsbeiträge!

2

Softwareentwicklung / Re: NASM: C-Funktion mit Parametern aufrufen

« am: 08. February 2013, 00:43 »

Und ein erneutes "Vielen Dank!"
Ja, links ist in meiner "Tabelle" die kleinere Adresse.
Eine letzte Frage hätte ich noch:
Sieht mein Speicher genau genommen nicht sogar so aus?

Code: [Auswählen]

+-------------------+------------------+------------------+------+------+
| Rücksprungadresse | 1. Parameter (3) | 2. Parameter (5) | leer | leer |
+-------------------+------------------+------------------+------+------+(Wieder 32 Bit / Bereich.)

Weil ich ja 16 Bit für die Parameter reserviert habe (mit sub 0x10) und nochmal 4 Bit für die Rücksprungadresse (mit dem call).
Ist das nicht ineffizient oder gar Speicherverschwendung?
Oder ist das egal, weil ja mein ESP (ich befinde mich gedanklich direkt nach der pop-Anweisung) momentan auf mein erstes Element zeigt (Rücksprungadresse).
Ich vermute mal dieser wird mit einem Aufruf von ret vom Stack gelöscht und so steht mein ESP auf dem ersten Parameter (?)

Bei einem erneuten Funktionsaufruf (nachdem meine Funktion das erste mal durchlaufen wurde) würde ich ja nun erneut Speicher auf dem Stack reservieren (sub esp, 0x10) und diesen wieder mit Parametern füllen. Aber wie kommen dann die Parameter vom ersten Funktionsaufruf wieder aus meinem Speicher raus? Die blockieren ja quasi den Speicher.
Was übersehe ich?

3

Softwareentwicklung / Re: NASM: C-Funktion mit Parametern aufrufen

« am: 06. February 2013, 20:21 »

Erstmal danke für die ausführlichen Antworten!

Den Aufrufkonventionen-Artikel hier habe ich schon gelesen, aber irgendwie die Funktion int test (int x) { return x; } außer acht gelassen. Nach euren Erklärungen erschliesst sich mir aber auch was da passiert.

Code: [Auswählen]

+-------------------+------------------+------------------+
| Rücksprungadresse | 1. Parameter (3) | 2. Parameter (5) |
+-------------------+------------------+------------------+Der Speicher sieht also so aus? (Angenommen die 5 Bereiche sind gleich groß (jeder 32bit)).

Wenn ich das in dem o.g. Wiki-Artikel richtig sehe, dann kann ich auch direkt auf ESP zugreifen, anstatt diesen zuerst in EBP zu verschieben?
Dann hätte ich mir doch ein paar Befehle gespart und die Rechnerei, wo denn nun meine Parameter liegen.

Wow! Ich fürchte bei so guten Erklärungen wird das nicht meine letzte Frage gewesen sein! (Achtung: Drohung)

Grüße und noch einen schönen Abend!

4

Softwareentwicklung / [solved] NASM: C-Funktion mit Parametern aufrufen

« am: 05. February 2013, 22:17 »

Hallo LowLevel-Community,
gleich vorweg: Ich bin ziemlich neu in Assembler!
Meine Frage: (Wie) ist es möglich aus (N)ASM eine Funktion aufzurufen, die ich in C (Compiler: GCC 4.6.2) geschrieben habe?
Bzw: Wie man eine Funktion aufruft weiss ich bereits, aber wie kann ich ihr Parameter übergeben?

Testweise habe ich mir ein kleines C-Programm geschrieben, welches eine eigene Funktion (fn) aufruft, die einfach die beiden integer-Parameter addiert und zurückgibt.
Dieses dann mit gcc -c source.c kompiliert und mit objdump -d -M intel source.o dann die Ausgabe des GCC-Compilers in einer Datei gespeichert.

Danach habe ich im C-Source den Funktionsaufruf auskommentiert und die beiden letzten Schritte wiederholt (Ausgabe dieses mal in einer anderen Datei gespeichert).

Wenn ich diese beiden Ausgabe-Dateien jetzt vergleiche, versteh ich nur Bahnhhof:

Code: [Auswählen]

00000000 <_fn>:
   0: 55                    push   ebp
   1: 89 e5                mov    ebp,esp
   3: 8b 45 0c              mov    eax,DWORD PTR [ebp+0xc]
   6: 8b 55 08              mov    edx,DWORD PTR [ebp+0x8]
   9: 01 d0                add    eax,edx
   b: 5d                    pop    ebp
   c: c3                    ret   

0000000d <_main>:
   d: 55                    push   ebp
   e: 89 e5                mov    ebp,esp
  10: 83 e4 f0              and    esp,0xfffffff0
+ 13: 83 ec 10              sub    esp,0x10
! 16: e8 00 00 00 00        call   1b <_main+0xe>
+ 1b: c7 44 24 04 05 00 00 mov    DWORD PTR [esp+0x4],0x5
+ 22: 00
+ 23: c7 04 24 03 00 00 00 mov    DWORD PTR [esp],0x3
+ 2a: e8 d1 ff ff ff        call   0 <_fn>
  2f: b8 00 00 00 00        mov    eax,0x0
  34: c9                    leave 
  35: c3                    ret   
  36: 90                    nop
+ 37: 90                    nop(Zeilen mit einem + am Anfang sind neu; Zeile mit ! wurde verändert)
Die veränderte Zeile war vorher
  18:   e8 00 00 00 00          call   18 <_main+0xb>

Speziell bei diesem Beispiel wären meine Fragen jetzt:

• Was macht das and esp, 0xfffffff0?
• Warum sub esp, 0x10?
• Was bringen die 2 Parameter bei den calls? Kenne das nur mit einem Label/Funktion (z.B. call print_string)

Ich vermute mal 1b und 23 verschieben meine Parameter (3 und 5) auf den Stack, aber warum jetzt an esp+4 und einmal an esp? (Frage geht einerher mit meiner 2. Frage)

Ich weiss, das sind eine Menge fragen und ich verlange gar nicht, dass die alle beantwortet werden! Es würde mir schon wahnsinnig helfen mir passende Links zu geben (das was ich bei Google gefunden habe, war das, was ich bereits gemacht und oben beschrieben habe) oder mir zumindest einen Schubs in die richtige Richtung zu geben!

Grüße
Meuchelfix77