调用栈基础

Every time your program calls a function or procedure, it uses a special area of memory called the call stack. Think of it like a stack of plates in a cafeteria. You can only add or remove plates from the top.

The call stack is crucial for managing function calls, local variables, and remembering where to return to after a function finishes.

The call stack operates on a LIFO principle: Last In, First Out. This means the last item added to the stack is always the first one to be removed.

• When a function is called, its data is 'pushed' onto the stack.
• When it returns, its data is 'popped' off.
• This ensures proper order for nested calls.

Two main registers are essential for managing the stack in x86 assembly:

• ESP (Stack Pointer): Always points to the top of the stack, the very last item pushed. The stack grows downwards (towards lower memory addresses).
• EBP (Base Pointer): Points to a fixed location within the current stack frame, helping locate local variables and function arguments.

We'll see how they work together to organize data.

The PUSH instruction adds data to the top of the stack. When you PUSH a value (e.g., a 32-bit register):

• The ESP register is first decremented by the size of the data (4 bytes for a 32-bit value).
• Then, the value is written to the memory location that ESP now points to.

It's like placing a new plate on top of the stack, which makes the stack 'taller' and its top move 'down'.

Observe how PUSH changes the stack pointer and stores values. In this example, assume ESP initially points to 0x100 (a high memory address). The stack grows downwards.

The POP instruction removes data from the top of the stack and places it into a specified register or memory location. When you POP a value:

• The value at the memory location currently pointed to by ESP is read.
• Then, the ESP register is incremented by the size of the data (e.g., 4 bytes).

This effectively 'removes' the top item and moves the pointer 'up', making the stack 'shorter'.

Let's see PUSH and POP working in sequence. Notice how ESP returns to its original position after an equal number of pushes and pops.

When a function (or procedure) is called, a dedicated region on the stack, called a stack frame (or activation record), is created for it. This frame holds all the data related to that specific function call.

A stack frame typically includes:

• Function arguments passed to it
• Local variables used within the function
• The return address (where the program should jump back to after the function finishes)
• Saved register values from the calling function

The EBP (Base Pointer) register is primarily used to manage stack frames. Unlike ESP, which constantly moves as data is pushed and popped, EBP usually remains fixed at the base of the current function's stack frame.

This stability makes it easy to access local variables and arguments using fixed offsets from EBP (e.g., [EBP-4] for a local variable, [EBP+8] for an argument), even if ESP changes due to pushes/pops within the function.

Consider the following assembly code snippet:

  mov eax, 10
  push eax
  mov ebx, 20
  push ebx
  pop ecx
  pop edx

What will be the final value in the EDX register after this code executes?

You've learned the basics of the x86 call stack!

• The call stack is a LIFO data structure fundamental for managing function calls.
• ESP (Stack Pointer) always points to the top of the stack and moves with PUSH/POP operations.
• EBP (Base Pointer) is used to define a stable stack frame for a function, helping access local data and arguments.
• PUSH decrements ESP then stores the value; POP retrieves the value then increments ESP.

Next, we'll build on this by learning how to define and call our own procedures, utilizing these stack concepts.