Ensamblador - Procedimientos (subrutinas)

Un procedimiento (Procedure) es un mecanismo en lenguaje ensamblador para implementar la reutilización de funciones/subrutinas, que permite que el código sea estructurado y reutilizable. Comprender la relación entre los procedimientos y la pila es un hito importante en la programación en ensamblador.


¿Qué es un procedimiento?

Un procedimientoes un bloque de código que puede ser invocado múltiples veces, similar a una función (Function) o subrutina (Subroutine) en lenguajes de alto nivel.

En ensamblador, un procedimiento se invoca mediante laCALLinstrucción CALL, y retorna mediante laRETinstrucción RET.CALLCALL empuja la dirección de retorno a la pila,RETRET extrae la dirección de retorno de la pila y salta de vuelta.

Ejemplo

; Ruta del archivo: simple_proc.asm
; El ejemplo más simple de llamada a un procedimiento

section .data
    msg db 'Hello, ejemplo!', 0xA
    len equ $ - msg

section .text
    global _start

_start:
    call print_message           ; Llamar al procedimiento (empuja la dirección de la siguiente instrucción a la pila)
    call print_message           ; Llamar de nuevo

    mov eax, 1
    mov ebx, 0
    int 0x80

; Procedimiento: imprime un mensaje
print_message:
    push eax                     ; Guardar los registros que se van a modificar
    push ebx
    push ecx
    push edx

    mov eax, 4
    mov ebx, 1
    mov ecx, msg
    mov edx, len
    int 0x80

    pop edx                      ; Restaurar los registros (en orden inverso)
    pop ecx
    pop ebx
    pop eax
    ret                          ; Retornar al punto de llamada (extrae la dirección de retorno de la pila)

Dentro de un procedimiento, se deben guardar y restaurar todos los registros que se modifiquen (excepto EAX cuando se usa como valor de retorno); esto es una regla básica de etiqueta en la programación en ensamblador. No hacerlo puede provocar que los valores de los registros del llamador se modifiquen inesperadamente.


Principio de CALL y RET

CALLyRETCALL y RET trabajan en pareja, dependiendo de la pila para gestionar la dirección de retorno:

InstrucciónOperación real ejecutada
CALL labelpush eip(Guardar la dirección de la siguiente instrucción) +jmp label
RETpop eip(Extraer la dirección de la pila y saltar)

Paso de parámetros mediante registros

Antes de llamar al procedimiento, colocar los parámetros en los registros acordados:

Ejemplo

; Ruta del archivo: proc_params_reg.asm
; Paso de parámetros mediante registros

section .data
    newline db 0xA

section .text
    global _start

_start:
    ; Llamar al procedimiento add_two: calcular 10 + 20
    mov eax, 10                  ; El primer parámetro se coloca en eax
    mov ebx, 20                  ; El segundo parámetro se coloca en ebx
    call add_two                 ; Llamar al procedimiento
    ; El valor de retorno está en eax = 30

    mov ebx, eax                 ; Código de salida = 30
    mov eax, 1
    int 0x80

; Procedimiento: calcula eax + ebx, el resultado se devuelve en eax
add_two:
    add eax, ebx                 ; eax = eax + ebx
    ret

Paso de parámetros mediante la pila

Pasar parámetros por la pila es más flexible y es el método estándar en lenguajes de alto nivel como C:

Ejemplo

; Ruta del archivo: proc_params_stack.asm
; Paso de parámetros mediante la pila (estilo cdecl)

section .data
    msg db 'Sum is: '
    msg_len equ $ - msg
    newline db 0xA

section .bss
    result_buf resb 4

section .text
    global _start

_start:
    ; Llamar al procedimiento sum: calcular 100 + 200
    push dword 200               ; Empujar el segundo parámetro
    push dword 100               ; Empujar el primer parámetro
    call sum                     ; Llamar al procedimiento
    add esp, 8                   ; ★ El llamador limpia la pila (convención cdecl)
    ; El valor de retorno está en eax = 300

    mov ebx, eax
    mov eax, 1
    int 0x80

; Procedimiento: sum(a, b) = a + b
sum:
    push ebp                     ; ★ Guardar el puntero base anterior
    mov ebp, esp                 ; ★ Establecer la nueva base del marco de pila

    ; Diseño de la pila (de dirección alta a dirección baja):
    ; [ebp+12] = parámetro b (200)
    ; [ebp+8] = parámetro a (100)
    ; [ebp+4] = dirección de retorno
    ; [ebp] = ebp anterior
    ; [ebp-4] = espacio para variables locales

    mov eax, [ebp + 8]           ; Obtener el primer parámetro (a)
    add eax, [ebp + 12]          ; Sumar el segundo parámetro (b)

    pop ebp                      ; ★ Restaurar el puntero base anterior
    ret                          ; Retornar

Diagrama de la estructura del marco de pila:

栈帧结构图

A continuación se muestra la representación textual correspondiente:

高地址
+------------------+
| 参数2 (200)      |  <-- [ebp + 12]
+------------------+
| 参数1 (100)      |  <-- [ebp + 8]
+------------------+
| 返回地址          |  <-- [ebp + 4]
+------------------+
| 旧的 EBP         |  <-- [ebp]  (当前 EBP 指向这里)
+------------------+
| 局部变量区        |  <-- [ebp - 4], [ebp - 8], ...
+------------------+  <-- ESP 指向这里
低地址

Prólogo de la función (Prologue)push ebp; mov ebp, espy Epílogo (Epilogue)pop ebp; ret(oleave; ret) son la plantilla estándar de gestión del marco de pila; casi todas las funciones en ensamblador comienzan y terminan con esta estructura.


Valor de retorno de un procedimiento

El valor de retorno normalmente se almacena en el registro EAX (valor de 32 bits) o en EDX:EAX (valor de 64 bits):

Ejemplo

; Ejemplo de valor de retorno

    ; Retornar un int
    call get_answer
    ; eax = 42

    ; Retornar un valor de 64 bits (como long long)
    call get_big_value
    ; edx:eax = resultado de 64 bits

get_answer:
    mov eax, 42                  ; El valor de retorno se coloca en eax
    ret

get_big_value:
    mov eax, 0x00000001          ; 32 bits bajos
    mov edx, 0x00000000          ; 32 bits altos
    ret

Variables locales

Las variables locales usan espacio de la pila, asignado en el prólogo del procedimiento disminuyendo ESP:

Ejemplo

; Ruta del archivo: local_vars.asm
; Uso de variables locales en un procedimiento

section .text
    global _start

_start:
    push dword 10
    push dword 20
    call multiply_add
    add esp, 8
    ; eax = 10 * 20 + 10 + 20 = 230

    mov ebx, eax
    mov eax, 1
    int 0x80

; Procedimiento: multiply_add(x, y) = x*y + x + y
multiply_add:
    push ebp
    mov ebp, esp
    sub esp, 8                   ; ★ Asignar 8 bytes de espacio para variables locales en la pila

    ; Ahora [ebp-4] y [ebp-8] son variables locales disponibles

    mov eax, [ebp + 8]           ; x
    mov ebx, [ebp + 12]          ; y

    ; [ebp-4] = x * y
    imul eax, ebx
    mov [ebp - 4], eax           ; Variable local 1 = x * y

    ; [ebp-8] = x + y
    mov eax, [ebp + 8]
    add eax, [ebp + 12]
    mov [ebp - 8], eax           ; Variable local 2 = x + y

    ; Valor de retorno = [ebp-4] + [ebp-8]
    mov eax, [ebp - 4]
    add eax, [ebp - 8]

    ; ★ Limpiar el espacio de variables locales y restaurar
    mov esp, ebp                  ; Equivalente a add esp, 8
    pop ebp
    ret

Las variables locales se asignan en el marco de pila y se liberan automáticamente cuando el procedimiento retorna. Usar laleaveinstrucción puede reemplazar amov esp, ebp; pop ebp, el efecto es equivalente.


Comparación de convenciones de llamada a procedimientos

ConvenciónPaso de parámetrosQuien limpia la pilaGuardado de registrosValor de retorno
cdeclPila (empujar de derecha a izquierda)LlamadorEAX, ECX, EDX guardados por el llamadorEAX
stdcallPila (empujar de derecha a izquierda)Llamado (callee)EAX, ECX, EDX guardados por el llamadorEAX
fastcallECX, EDX + pilaLlamado (callee)EAX, ECX, EDX guardados por el llamadorEAX
Otras extensiones