perché usare ebp in funzione prologo/epilogo?

Question

Qualche tempo fa stavo sperimentando con il gruppo di scrittura routine e il collegamento con i programmi in C e ho trovato che ho appena posso saltare di serie C-call prologo all'epilogo

push ebp 
    mov ebp, esp 
    (sub esp, 4 
    ... 
    mov esp, ebp) 
    pop ebp 

basta saltare tutto e indirizzo semplicemente esp , come

mov eax, [esp+4]   ;; take argument 
    mov [esp-4], eax   ;; use some local variable storage 

Sembra funzionare abbastanza bene. Perché questo ebp è usato - è forse indirizzarsi attraverso ebp più veloce o cosa?

Answer 1

Non c'è alcun obbligo di utilizzare uno stack frame, ma ci sono sicuramente alcuni vantaggi:

In primo luogo , se ogni funzione ha utilizzato questo stesso processo, possiamo usare questa conoscenza per determinare facilmente una sequenza di chiamate (lo stack di chiamate) invertendo il processo. Sappiamo che dopo un'istruzione call, ESP punti per l'indirizzo di ritorno e che la prima cosa che la funzione chiamata farà è push l'attuale EBP e quindi copiare ESP in EBP. Quindi, in qualsiasi momento possiamo guardare i dati indicati da EBP che sarà il precedente EBP e che EBP+4 sarà l'indirizzo di ritorno dell'ultima chiamata di funzione. Possiamo quindi stampare il (32bit assumendo) stack di chiamate utilizzando qualcosa di simile (scusate il arrugginita C++):

void LogStack(DWORD ebp) 
{ 
    DWORD prevEBP = *((DWORD*)ebp); 
    DWORD retAddr = *((DWORD*)(ebp+4)); 

    if (retAddr == 0) return; 

    HMODULE module; 
    GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*)retAddr, &module); 
    char* fileName = new char[256]; 
    fileName[255] = 0; 
    GetModuleFileNameA(module, fileName, 255); 
    printf("0x%08x: %s\n", retAddr, fileName); 
    delete [] fileName; 
    if (prevEBP != 0) LogStack(prevEBP); 
} 

Questo sarà quindi stampare l'intera sequenza di chiamate (o meglio, i loro indirizzi di ritorno) fino a quel momento.

Inoltre, dal momento che EBP non cambia a meno che non si aggiorna in modo esplicito che (a differenza di ESP, che cambia quando si push/pop), di solito è più facile fare riferimento i dati nello stack rispetto al EBP, piuttosto che rispetto al ESP, dal momento che con quest'ultimo, è necessario essere a conoscenza di tutte le istruzioni push/pop che potrebbero essere state chiamate tra l'inizio della funzione e il riferimento.

Come altri hanno detto, si dovrebbe evitare di utilizzare pila indirizzi sottoESP come qualsiasi call s fate ad altre funzioni sono suscettibili di sovrascrivere i dati a questi indirizzi.Si dovrebbe invece riservare spazio sullo stack per l'utilizzo da parte vostra funzione dal solito:

sub esp, [number of bytes to reserve] 

Dopo questo, la regione dello stack tra il primo e ESPESP - [number of bytes reserved] è sicuro da usare. Prima di uscire la funzione è necessario liberare lo spazio di stack riservato utilizzando una corrispondenza:

add esp, [number of bytes reserved] 

Answer 2

Funziona, tuttavia, una volta ricevuto un interrupt, il processore sposterà tutti i suoi registri e flag nello stack, sovrascrivendo il valore. Lo stack è lì per un motivo, usarlo ...

Answer 3

L'uso di EBP è di grande aiuto durante il debug del codice, in quanto consente ai debugger di attraversare i frame dello stack in una catena di chiamate.

It [crea] una lista concatenata che collegava il puntatore per ciascuno dei chiamanti a una funzione. Da EBP per una routine, è possibile recuperare l'intero stack di chiamate per una funzione.

Vedi http://en.wikibooks.org/wiki/X86_Disassembly/Functions_and_Stack_Frames
E in particolare la pagina di link ad esso che copre la tua domanda: http://blogs.msdn.com/b/larryosterman/archive/2007/03/12/fpo.aspx