Schnittstellen zu Hochsprachen

[f0rtex]

Hallo Leute

Ich gehe vom folgenden Programm aus:



void function(int a, int b, int c)
{
char buffer1[5];
char buffer2[10];
}

void main()
{
function(1,2,3);
}


Der Compiler macht zuerst mal 3 PUSH's um die Parameter a, b, c auf den Stack zu Pushen. Dann wird noch Speicher für die zwei lokalen Buffer auf dem Stack reserviert.

Ein gcc -S liefert folgenden Output:


...
push dword 3
push dword 2
push dword 1
call function
...
push ebp
mov ebp,esp
sub esp,40


Nun sieht der Stack also wie folgt aus:


+-----------+
| buffer2 | <-- Top of Stack
+-----------+
| buffer1 |
+-----------+
| bp |
+-----------+
| ret | (Instruction Pointer)
+-----------+
| a |
+-----------+
| b |
+-----------+
| c |
+-----------+


Nun, soweit ich mich erinnern kann, kann der Stack nur als vielfaches von 4 Bytes adressiert werden.
D.h. doch, dass ich für den buffer1 8 Bytes und für den buffer2 12 Bytes auf dem Stack reserviern muss?

Mich verwirrt nun folgendes:
Wieso macht der gcc ein


sub esp, 40

anstatt ein


sub esp, 20

?

Ich hoffe, dass meine Frage verständlich ist.


Best wishes

f0rtex

[wraith]

Dass hängt alles vom Compiler und/oder den Optimierungen ab.
Compile mal auf Größe optimiert (-Os),dann kommt wieder ein anderer Wert raus.
Ein anderer Compiler den ich getestet habe,macht tatsächlich das von dir angenommene sub esp,20.
Ich denke das gcc etwas mehr anlegt,um sich einen Sicherheitspuffer gegen Bufferoverflows zu verschaffen.

Btw, genauso die Sache,das die drei Argumente auf den Stack gepusht werden,ist von Compiler zu Compiler verschieden,und von der Optimierung abhängig.
Es ist eher unüblich native Funktionsargumente auf den Stack zu pushen (wozu gibt es Register).

[f0rtex]

Dass hängt alles vom Compiler und/oder den Optimierungen ab.
Compile mal auf Größe optimiert (-Os),dann kommt wieder ein anderer Wert raus.


Mit -Os -O3 kommt er auf sub esp, 32.
Nach welchen kriterien optimiert der gcc (3.2.3)?



Ich denke das gcc etwas mehr anlegt,um sich einen Sicherheitspuffer gegen Bufferoverflows zu verschaffen.

Das nütz nicht viel.



Btw, genauso die Sache,das die drei Argumente auf den Stack gepusht werden,ist von Compiler zu Compiler verschieden,und von der Optimierung abhängig.
Es ist eher unüblich native Funktionsargumente auf den Stack zu pushen (wozu gibt es Register).

Argumente werden normalerweise via STACK übergeben. Der Returnwert wird im eax hinterlegt.

Mit welchem Compiler kommst du auf sub esp, 20?

Greets
f0rtex

[wraith]

Original geschrieben von f0rtex
Argumente werden normalerweise via STACK übergeben.

Kommentar aus Deep C Programming von Peter van der Linden (Hat Compiler bei Sun geschrieben)


Some C books make statements
like "parameters are passed to a called function by pushing them on the stack from right to left." This
is oversimplification—if you own such a book, tear out that page and burn it. If you own such a
compiler, tear out those bytes. Parameters are passed in registers (for speed) where possible.




Mit welchem Compiler kommst du auf sub esp, 20?

Microsoft VC++ 7.1

[f0rtex]

Danke für das Zitat :)

Werde es meinem Prof weiterleiten. Mal kucken wie er darauf reagiert :)
Werde mal in den Internals vom gcc "rumschnöckern".

Greets
f0rtex