En este tema, aprenderemos sobre subrutinas y procedimientos en el lenguaje ensamblador. Las subrutinas y procedimientos son bloques de código que se pueden llamar desde diferentes partes de un programa, lo que permite la reutilización del código y una mejor organización.

Conceptos Clave

  1. Subrutina: Un bloque de código que realiza una tarea específica y puede ser llamado desde cualquier parte del programa.
  2. Procedimiento: Similar a una subrutina, pero generalmente se refiere a un bloque de código que puede recibir parámetros y devolver valores.
  3. Llamada a subrutina: La instrucción que transfiere el control del programa a la subrutina.
  4. Retorno de subrutina: La instrucción que devuelve el control del programa al punto desde donde se llamó la subrutina.

Estructura de una Subrutina

Una subrutina en ensamblador generalmente sigue esta estructura:

  1. Prologo: Código que se ejecuta al inicio de la subrutina para preparar el entorno.
  2. Cuerpo: El código principal de la subrutina.
  3. Epilogo: Código que se ejecuta al final de la subrutina para limpiar el entorno y retornar al punto de llamada.

Ejemplo de Subrutina en x86 Assembly

A continuación, se muestra un ejemplo de una subrutina simple en ensamblador x86 que suma dos números:

section .data
    num1 db 5
    num2 db 10
    result db 0

section .text
    global _start

_start:
    ; Llamada a la subrutina sum
    call sum

    ; Salida del programa
    mov eax, 1          ; syscall: exit
    int 0x80

sum:
    ; Prologo
    push ebp            ; Guardar el valor de EBP
    mov ebp, esp        ; Establecer el nuevo valor de EBP

    ; Cuerpo
    mov al, [num1]      ; Cargar num1 en AL
    add al, [num2]      ; Sumar num2 a AL
    mov [result], al    ; Guardar el resultado

    ; Epilogo
    mov esp, ebp        ; Restaurar el valor de ESP
    pop ebp             ; Restaurar el valor de EBP
    ret                 ; Retornar al punto de llamada

Explicación del Código

  1. Prologo:

    • push ebp: Guarda el valor del registro EBP en la pila.
    • mov ebp, esp: Establece el nuevo valor de EBP al valor actual de ESP.
  2. Cuerpo:

    • mov al, [num1]: Carga el valor de num1 en el registro AL.
    • add al, [num2]: Suma el valor de num2 al registro AL.
    • mov [result], al: Guarda el resultado de la suma en la variable result.
  3. Epilogo:

    • mov esp, ebp: Restaura el valor de ESP al valor que tenía antes de la llamada a la subrutina.
    • pop ebp: Restaura el valor de EBP.
    • ret: Retorna al punto de llamada.

Ejercicio Práctico

Ejercicio 1: Crear una Subrutina para Multiplicar Dos Números

Escribe una subrutina en ensamblador x86 que multiplique dos números y almacene el resultado en una variable.

Solución

section .data
    num1 db 4
    num2 db 3
    result db 0

section .text
    global _start

_start:
    ; Llamada a la subrutina multiply
    call multiply

    ; Salida del programa
    mov eax, 1          ; syscall: exit
    int 0x80

multiply:
    ; Prologo
    push ebp            ; Guardar el valor de EBP
    mov ebp, esp        ; Establecer el nuevo valor de EBP

    ; Cuerpo
    mov al, [num1]      ; Cargar num1 en AL
    mov bl, [num2]      ; Cargar num2 en BL
    mul bl              ; Multiplicar AL por BL, resultado en AX
    mov [result], al    ; Guardar el resultado (parte baja de AX)

    ; Epilogo
    mov esp, ebp        ; Restaurar el valor de ESP
    pop ebp             ; Restaurar el valor de EBP
    ret                 ; Retornar al punto de llamada

Explicación del Código

  1. Prologo:

    • push ebp: Guarda el valor del registro EBP en la pila.
    • mov ebp, esp: Establece el nuevo valor de EBP al valor actual de ESP.
  2. Cuerpo:

    • mov al, [num1]: Carga el valor de num1 en el registro AL.
    • mov bl, [num2]: Carga el valor de num2 en el registro BL.
    • mul bl: Multiplica el valor de AL por BL, el resultado se almacena en AX.
    • mov [result], al: Guarda el resultado de la multiplicación (parte baja de AX) en la variable result.
  3. Epilogo:

    • mov esp, ebp: Restaura el valor de ESP al valor que tenía antes de la llamada a la subrutina.
    • pop ebp: Restaura el valor de EBP.
    • ret: Retorna al punto de llamada.

Conclusión

En esta sección, hemos aprendido sobre subrutinas y procedimientos en ensamblador, su estructura y cómo implementarlas. Las subrutinas permiten la reutilización del código y una mejor organización del programa. Hemos visto ejemplos prácticos y realizado un ejercicio para reforzar los conceptos aprendidos. En el siguiente tema, exploraremos las operaciones con la pila, que son fundamentales para el manejo de subrutinas y procedimientos.

© Copyright 2024. Todos los derechos reservados