Stack Based Parameter Passing

Stack-based parameter passing is a fundamental technique in x86 assembly language programming. It involves pushing function parameters onto the stack before calling a function, allowing for flexible and organized parameter management. This method is particularly useful in complex applications and systems programming where performance and memory management are critical.

Overview of Stack-Based Parameter Passing

In x86 assembly language, the stack is a data structure that operates in a last-in, first-out (LIFO) manner. When a function is called, parameters can be pushed onto the stack in a specific order. The function then accesses these parameters by referencing their positions on the stack relative to the base pointer (EBP).

How It Works:

1. Push Parameters: The caller pushes the parameters onto the stack in reverse order (right to left).
2. Call the Function: The caller uses the call instruction to transfer control to the function.
3. Set Up Stack Frame: The function sets up its stack frame, typically by saving the base pointer (EBP) and setting it to the current stack pointer (ESP).
4. Access Parameters: The function accesses the parameters on the stack using the base pointer (EBP).
5. Clean Up Stack Frame: After the function completes, it cleans up its stack frame and returns control to the caller using the ret instruction.

Example: Simple Stack-Based Function

Let's start with a simple example: a function that adds two integers passed via the stack and returns the result in the EAX register.

section .text
global _start

_start:
    ; Push parameters in reverse order
    push dword 5      ; Second parameter
    push dword 10     ; First parameter
    call add_numbers
    add esp, 8        ; Clean up the stack (2 * 4 bytes)
    
    ; The result of the addition is now in EAX

    ; Exit the program
    mov eax, 1        ; sys_exit
    xor ebx, ebx      ; Exit code 0
    int 0x80          ; Interrupt to exit

; Define the add_numbers function
add_numbers:
    push ebp
    mov ebp, esp

    ; Access parameters from the stack
    mov eax, [ebp+8]  ; First parameter
    mov ebx, [ebp+12] ; Second parameter
    add eax, ebx      ; Add the parameters

    pop ebp
    ret

In this example:

• The _start section pushes two integers onto the stack in reverse order (10 and 5).
• The call instruction transfers control to the add_numbers function.
• Inside the add_numbers function:
  • The base pointer (EBP) is saved and set to the current stack pointer (ESP).
  • The parameters are accessed using offsets from the base pointer ([EBP+8] for the first parameter and [EBP+12] for the second).
  • The parameters are added, and the result is stored in the EAX register.
  • The stack frame is cleaned up, and control is returned to the caller.

Advantages of Stack-Based Parameter Passing

1. Scalability: Easily handles a large number of parameters. Functions can accept varying numbers of arguments without changing the calling convention.
2. Reentrancy: Supports recursive function calls and reentrant code, as each function call maintains its own stack frame.
3. Consistent Calling Convention: Standardizes function calls, making the code easier to understand and maintain.
4. Memory Management: The stack is automatically managed by the system, simplifying memory allocation and deallocation for function parameters.

Disadvantages of Stack-Based Parameter Passing

1. Performance Overhead: Pushing and popping parameters on and off the stack can introduce performance overhead, especially for small, frequently called functions.
2. Complexity: Requires careful management of the stack frame, which can be error-prone for beginners.
3. Limited by Stack Size: The stack has a limited size, and excessive use can lead to stack overflow, especially in deeply nested function calls or with large parameters.
4. Extra Instructions: Requires additional instructions for pushing parameters, setting up the stack frame, and cleaning up, which can increase code size.

Example: More Complex Function with Multiple Parameters

Consider a more complex example: a function that takes three integers, multiplies the first two, adds the third, and returns the result.

section .text
global _start

_start:
    ; Push parameters in reverse order
    push dword 3      ; Third parameter
    push dword 7      ; Second parameter
    push dword 5      ; First parameter
    call multiply_add
    add esp, 12       ; Clean up the stack (3 * 4 bytes)
    
    ; The result of the operation is now in EAX

    ; Exit the program
    mov eax, 1        ; sys_exit
    xor ebx, ebx      ; Exit code 0
    int 0x80          ; Interrupt to exit

; Define the multiply_add function
multiply_add:
    push ebp
    mov ebp, esp

    ; Access parameters from the stack
    mov eax, [ebp+8]  ; First parameter
    mov ebx, [ebp+12] ; Second parameter
    mov ecx, [ebp+16] ; Third parameter
    imul eax, ebx     ; EAX = first * second
    add eax, ecx      ; EAX = EAX + third

    pop ebp
    ret

In this example:

• Three parameters are pushed onto the stack in reverse order.
• The multiply_add function accesses these parameters using the base pointer.
• The function multiplies the first two parameters and adds the third, storing the result in EAX.
• The stack frame is cleaned up, and control is returned to the caller.