Considerazioni sulla scrittura di codice di prologo/epilogoConsiderations When Writing Prolog/Epilog Code

Sezione specifica MicrosoftMicrosoft Specific

Prima di scrivere le proprie sequenze di codice di prologo ed epilogo, è importante comprendere il layout dello stack frame. È anche utile sapere come usare la costante predefinita __LOCAL_SIZE.Before writing your own prolog and epilog code sequences, it is important to understand how the stack frame is laid out. It is also useful to know how to use the __LOCAL_SIZE predefined constant.

Layout dello stack frame C C Stack Frame Layout

In questo esempio viene illustrato il codice standard di prologo che potrebbe essere visualizzato in una funzione a 32 bit:This example shows the standard prolog code that might appear in a 32-bit function:

push     ebp                 ; Save ebp  
mov      ebp, esp            ; Set stack frame pointer  
sub      esp, localbytes     ; Allocate space for locals  
push     <registers>         ; Save registers  

La variabile localbytes rappresenta il numero di byte necessari nello stack per le variabili locali e la variabile registers è un segnaposto che rappresenta l'elenco di registri da salvare nello stack.The localbytes variable represents the number of bytes needed on the stack for local variables, and the registers variable is a placeholder that represents the list of registers to be saved on the stack. Dopo l'inserimento dei registri, è possibile posizionare qualsiasi altro dato appropriati nello stack.After pushing the registers, you can place any other appropriate data on the stack. Viene di seguito riportato il codice di epilogo corrispondente.The following is the corresponding epilog code:

pop      <registers>         ; Restore registers  
mov      esp, ebp            ; Restore stack pointer  
pop      ebp                 ; Restore ebp  
ret                          ; Return from function  

Lo stack va sempre verso il basso (dal livello alto a quello basso degli indirizzi di memoria).The stack always grows down (from high to low memory addresses). Il puntatore di base (ebp) punta al valore inserito di ebp.The base pointer (ebp) points to the pushed value of ebp. La sezione variabili locali inizia a ebp-2.The local variables area begins at ebp-2. Per accedere alle variabili locali, calcolare un offset da ebp sottraendo il valore appropriato da ebp.To access local variables, calculate an offset from ebp by subtracting the appropriate value from ebp.

Costante __LOCAL_SIZE The __LOCAL_SIZE Constant

Il compilatore specifica una costante __LOCAL_SIZE da usare nel blocco dell'assembler inline del codice di prologo di una funzione.The compiler provides a constant, __LOCAL_SIZE, for use in the inline assembler block of function prolog code. Questa costante viene utilizzata per allocare spazio per le variabili locali sullo stack frame nel codice di prologo.This constant is used to allocate space for local variables on the stack frame in custom prolog code.

Il compilatore determina il valore di __LOCAL_SIZE.The compiler determines the value of __LOCAL_SIZE. Il valore è il numero totale di byte di tutte le variabili locali definite dall'utente e le variabili temporanee generate dal compilatore.The value is the total number of bytes of all user-defined local variables and compiler-generated temporary variables. __LOCAL_SIZE può essere usata solo come operando immediato; non può essere usata in un'espressione.__LOCAL_SIZE can be used only as an immediate operand; it cannot be used in an expression. Non è necessario modificare o ridefinire il valore di questa costante.You must not change or redefine the value of this constant. Ad esempio:For example:

mov      eax, __LOCAL_SIZE           ;Immediate operand--Okay  
mov      eax, [ebp - __LOCAL_SIZE]   ;Error  

Il seguente esempio di funzione naked che contiene sequenze di prologo ed epilogo personalizzate usa __LOCAL_SIZE nella sequenza del prologo:The following example of a naked function containing custom prolog and epilog sequences uses __LOCAL_SIZE in the prolog sequence:

__declspec ( naked ) func()  
{  
   int i;  
   int j;  

   __asm      /* prolog */  
      {  
      push   ebp  
      mov      ebp, esp  
      sub      esp, __LOCAL_SIZE  
      }  

   /* Function body */  

   __asm      /* epilog */  
      {  
      mov      esp, ebp  
      pop      ebp  
      ret  
      }  
}     

Fine sezione specifica MicrosoftEND Microsoft Specific

Vedere ancheSee Also

Funzioni nakedNaked Functions