User Guide

General-Purpose Programming 45
24592—Rev. 3.15—November 2009 AMD64 Technology
PUSHA or PUSHAD stores eight word-sized or doubleword-sized registers onto the stack: eAX, eCX,
eDX, eBX, eSP, eBP, eSI and eDI, in that order. The stored value of eSP is sampled at the moment
when the PUSHA instruction started. The resulting stack-pointer value is decremented by 16 or 32.
POPA or POPAD extracts eight word-sized or doubleword-sized registers from the stack: eDI, eSI,
eBP, eSP, eBX, eDX, eCX and eAX, in that order (which is the reverse of the order used in the PUSHA
instruction). The stored eSP value is ignored by the POPA instruction. The resulting stack pointer
value is incremented by 16 or 32.
It is a common practice to use PUSH instructions to pass parameters (via the stack) to functions and
subroutines. The typical instruction sequence used at the beginning of a subroutine looks like:
push ebp ; save current EBP
mov ebp, esp ; set stack frame pointer value
sub esp, N ; allocate space for local variables
The rBP register is used as a stack frame pointer—a base address of the stack area used for parameters
passed to subroutines and local variables. Positive offsets of the stack frame pointed to by rBP provide
access to parameters passed while negative offsets give access to local variables. This technique allows
creating re-entrant subroutines.
The ENTER and LEAVE instructions provide support for procedure calls, and are mainly used in high-
level languages. The ENTER instruction is typically the first instruction of the procedure, and the
LEAVE instruction is the last before the RET instruction.
The ENTER instruction creates a stack frame for a procedure. The first operand, size, specifies the
number of bytes allocated in the stack. The second operand, depth, specifies the number of stack-frame
pointers copied from the calling procedure’s stack (i.e., the nesting level). The depth should be an
integer in the range 0–31.
Typically, when a procedure is called, the stack contains the following four components:
• Parameters passed to the called procedure (created by the calling procedure).
• Return address (created by the CALL instruction).
• Array of stack-frame pointers (pointers to stack frames of procedures with smaller nesting-level
depth) which are used to access the local variables of such procedures.
• Local variables used by the called procedure.
All these data are called the stack frame. The ENTER instruction simplifies management of the last
two components of a stack frame. First, the current value of the rBP register is pushed onto the stack.
The value of the rSP register at that moment is a frame pointer for the current procedure: positive
offsets from this pointer give access to the parameters passed to the procedure, and negative offsets
give access to the local variables which will be allocated later. During procedure execution, the value
of the frame pointer is stored in the rBP register, which at that moment contains a frame pointer of the
calling procedure. This frame pointer is saved in a temporary register. If the depth operand is greater
than one, the array of depth-1 frame pointers of procedures with smaller nesting level is pushed onto
the stack. This array is copied from the stack frame of the calling procedure, and it is addressed by the