ASM / C - Speicherbelegung im Stack

uTaNG

Hallo, ich beschäftige mich gerade n bissel mit dem Stack, allerdings ist mir etwas unklar.

mein C-Prog

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

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

Es werden für den Speicher 4 Bytes[1 Wort] reserviert und aufgerundet. Demnach für buffer1 = 8 Bytes[2 Wörter] und buffer2 = 12 Bytes [3 Wörter] und das machen insgesamt 20 Bytes.

Demnach sollte im Prolog der Funktion folgender ASM-Code sein....

pushl %ebp
        movl %esp,%ebp
        subl $20,%esp

als sollte er vom Stackpointer die Größe der Variablen[20] abziehen. Aber mein erzeugter Code sieht etwas anders aus. Er zieht bei mir 40 statt 20 ab und ich weiss nicht wie er auf 40 kommt ...

.file   "example.c"
        .text
.globl function
        .type   function, @function
function:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $40, %esp
        leave
        ret
        .size   function, .-function
.globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        andl    $-16, %esp
        movl    $0, %eax
        subl    %eax, %esp
        movl    $3, 8(%esp)
        movl    $2, 4(%esp)
        movl    $1, (%esp)
        call    function
        leave
        ret
        .size   main, .-main
        .section        .note.GNU-stack,"",@progbits

Ringding

Ich kann das Verhalten reproduzieren und bin ehrlichgesagt auch etwas überrascht, aber grundsätzlich gilt: der Compiler darf machen, was er will.

Jedenfalls erweckt es den Anschein, dass er alles auf 16 Bytes alignen will. Das macht zwei 16 Byte-Blöcke + ein bisschen magic (der Return-EIP muss ja auch irgendwo hin).

uTaNG

hallo, also mit Hilfe von lizer, jemand von dem anderem Board haben wir festgestellt,dass wenn wir ein Array mit 15 Bytes nehmen. Das also auf 16 Bytes aufgerundet wird, im Stack nur 24 Bytes reserviert werden statt 40.

einen informativen Link haben wir gefunden,dennoch wäre es nicht schlecht wen wir das allse rechnerisch Nachvolziehen könnten.

der Link = http://www.dis.com/gnu/gccint/Function-Entry.html

vlt. finden wir noch was trotzdem danke

rocksteady

Benutzt du als Compiler einen gcc der 3.xx Version?

uTaNG

ja... einen 3.3.5

rocksteady

gcc Compiler der Versionen 3.xx reservieren meistens mehr Speicher als nötig, das soll wohl Buffer Overflows erschweren.

Ringding

Ich hab's dir ja eh schon vorgerechnet: 1. Array auf 16 aufgerundet + 2. Array auf 16 aufgerundet + so viel, dass der nächste Aufruf wieder aligned sein kann.