Où le pointeur de trame pointe-t-il après la configuration?

Question

Bien que je regarde les manuels scolaires pour comprendre cela, j'ai des problèmes.

0x08048b29 <func+0>: push %ebp 
    0x08048b2a <func+1>: mov %esp,%ebp 
    0x08048b2c <func+3>: push %ebx 
    ... 
    0x08048b30 <phase_2+7>: lea -0x28(%ebp),%eax 

Dans l'instruction Ica, je comprends que% eax obtient la valeur à 0x28 avant% ebp, mais où est-ce exactement? Est-ce 0x8048b29 - 0x28 (0x28 avant le début de la fonction) ou quoi?

Answer 1

Le registre ebp est généralement utilisé dans une fonction pour accéder à tous les arguments transmis à la fonction. Avant que cette fonction soit appelée, tous les arguments qui ne sont pas transmis par le registre sont poussés dans la pile. Au démarrage de cette fonction, le pointeur de base de la fonction appelante est sauvegardé.

(1) 0x08048b29 <func+0>: push %ebp

Le nouveau sommet de la pile est copié dans ebp pour servir de pointeur de base dans cette fonction.

(2) 0x08048b2a <func+1>: mov %esp,%ebp

Enfin, EBX est sauvé, ce qui était probablement une variable passée à la fonction dans un registre.

(3) 0x08048b2c <func+3>: push %ebx

Après tout ce code d'entrée de fonction, le registre ebp est pointant vers le milieu de la pile. Au-dessus, sur la pile (vers les objets poussés les plus récents) se trouve la valeur ebx qui a été poussée au # 3 ci-dessus. Au-dessous de lui sur la pile sont l'ancien ebp de la fonction d'appel (sauvé dans # 1 ci-dessus) et surtout ... tous les arguments passés à cette fonction via la pile (fait avant que la fonction a été appelée).

(4) lea -0x28(%ebp),%eax

La dernière instruction fait référence à l'un de ces arguments transmis par la pile. ebp finit par pointer dans la pile, pas à l'une des adresses de code des fonctions. C'est assez normal pour ebp, il est le plus souvent utilisé comme un pointeur dans la pile.

Answer 2

Regardez cela dans le contexte de appelant cette fonction. Le code qui le fait ressemble à quelque chose comme:

caller+...: push argN 
caller+...: ... 
caller+...: push arg0 
caller+...: call func 

-à-dire les arguments sont mis sur la pile dans cet ordre que, à l'entrée de func(), la pile aura la mise en page suivante:

[esp+(N*4)] : argN 
...   : arg(N-1)...arg2 
[esp+4 ] : arg1 
[esp  ] : <return address to caller()+...> 

Ensuite, vous effectuez la séquence push %ebp; mov %esp, %ebp, qui change%esp (par -4) afin que votre mise en page est maintenant:

[ebp+4+(N*4)][esp+(N*4)] : argN 
...      : arg(N-1)...arg2 
[ ebp+8  ][esp+8 ] : arg1 
[ ebp+4  ][esp+4 ] : <return address to caller()+...> 
[ ebp  ][esp  ] : <saved %ebp of caller> 

Le code continue ensuite à pousser un peu plus de registres sur la pile - puisque cela augmente à chaque fois que %esp est modifié par -4. En fin de compte (que vous n'avez pas montré dans votre démontage mais il sera là) vous aurez une instruction subl $..., %esp. Qui est ce qui alloue de l'espace pour vos variables locales.La mise en page de la pile finale est quelque chose comme:

[ebp+4+(N*4)][   ] : argN 
...      : arg(N-1)...arg2 
[ ebp+8  ][   ] : arg1 
[ ebp+4  ][   ] : <return address to caller()+...> 
[ ebp  ][   ] : <saved %ebp of caller> 
[ ebp-4  ][   ] : <saved %ebx of caller> 
[ ebp-8  ][   ] : ... 
...      : region for local variables 
[ ebp-?? ][ esp  ] : end of stack for func() 

Toute adresse entre [esp ... ebp-4] est dans ce qu'on appelle le cadre de pile pour votre fonction, et il contient soit un registre enregistrée au nom de l'appelant (comme ebx dans le cas du démontage montré par vous) ou des variables locales. Par conséquent, lorsque votre code affiche un accès à %ebp - XX, il se trouve dans l'espace des variables locales, si vous voyez %ebp + YY, il se trouve dans l'espace contenant les arguments de la fonction.