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
; 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ón | Operación real ejecutada |
|---|---|
CALL label | push eip(Guardar la dirección de la siguiente instrucción) +jmp label |
RET | pop 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
; 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
; 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
; 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
; 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 la
leaveinstrucción puede reemplazar amov esp, ebp; pop ebp, el efecto es equivalente.
Comparación de convenciones de llamada a procedimientos
| Convención | Paso de parámetros | Quien limpia la pila | Guardado de registros | Valor de retorno |
|---|---|---|---|---|
| cdecl | Pila (empujar de derecha a izquierda) | Llamador | EAX, ECX, EDX guardados por el llamador | EAX |
| stdcall | Pila (empujar de derecha a izquierda) | Llamado (callee) | EAX, ECX, EDX guardados por el llamador | EAX |
| fastcall | ECX, EDX + pila | Llamado (callee) | EAX, ECX, EDX guardados por el llamador | EAX |