Las sentencias condicionales son fundamentales en cualquier lenguaje de programación, incluido el ensamblador. Permiten que el flujo del programa cambie en función de ciertas condiciones, lo que es esencial para la toma de decisiones en el código.

Conceptos Clave

  1. Comparaciones: Las comparaciones son operaciones que evalúan dos valores y determinan su relación (igual, mayor, menor, etc.).
  2. Saltos Condicionales: Basados en el resultado de una comparación, los saltos condicionales permiten que el flujo del programa se desvíe a diferentes partes del código.
  3. Instrucciones de Salto: Instrucciones específicas que realizan saltos basados en condiciones.

Instrucciones de Comparación

En ensamblador, las comparaciones se realizan utilizando instrucciones específicas. En la arquitectura x86, la instrucción CMP (compare) es comúnmente utilizada.

Ejemplo de Instrucción CMP

CMP AX, BX

Esta instrucción compara el contenido de los registros AX y BX. No modifica los registros, pero establece los flags (banderas) del procesador según el resultado de la comparación.

Flags del Procesador

Las banderas del procesador son bits que indican el resultado de operaciones aritméticas y lógicas. Las más relevantes para las comparaciones son:

  • ZF (Zero Flag): Se establece si el resultado de la comparación es cero (los valores son iguales).
  • SF (Sign Flag): Indica el signo del resultado (positivo o negativo).
  • CF (Carry Flag): Se establece si hay un acarreo en una operación aritmética (útil para comparaciones de valores sin signo).
  • OF (Overflow Flag): Indica si hubo un desbordamiento en una operación aritmética.

Instrucciones de Salto Condicional

Las instrucciones de salto condicional permiten cambiar el flujo del programa basado en el estado de las banderas. Algunas de las más comunes en x86 son:

Instrucción Descripción Condición
JE / JZ Salta si igual / cero ZF = 1
JNE / JNZ Salta si no igual / no cero ZF = 0
JG / JNLE Salta si mayor (signed) ZF = 0 y SF = OF
JGE / JNL Salta si mayor o igual (signed) SF = OF
JL / JNGE Salta si menor (signed) SF ≠ OF
JLE / JNG Salta si menor o igual (signed) ZF = 1 o SF ≠ OF
JA / JNBE Salta si mayor (unsigned) CF = 0 y ZF = 0
JAE / JNB Salta si mayor o igual (unsigned) CF = 0
JB / JNAE Salta si menor (unsigned) CF = 1
JBE / JNA Salta si menor o igual (unsigned) CF = 1 o ZF = 1

Ejemplo de Salto Condicional

CMP AX, BX
JE equal_label
; Código si AX no es igual a BX
JMP end_label
equal_label:
; Código si AX es igual a BX
end_label:

En este ejemplo, si AX es igual a BX, el flujo del programa saltará a equal_label. Si no son iguales, el flujo continuará y luego saltará a end_label.

Ejercicio Práctico

Ejercicio 1: Comparar dos números y saltar según el resultado

Escribe un programa en ensamblador que compare dos números almacenados en los registros AX y BX. Si AX es mayor que BX, salta a una etiqueta llamada greater. Si AX es menor o igual a BX, salta a una etiqueta llamada not_greater.

Solución

section .data
    ; No se necesita sección de datos para este ejercicio

section .text
    global _start

_start:
    ; Asignar valores a los registros
    MOV AX, 10
    MOV BX, 5

    ; Comparar AX y BX
    CMP AX, BX

    ; Saltar según el resultado de la comparación
    JG greater
    JMP not_greater

greater:
    ; Código si AX es mayor que BX
    ; (Por ejemplo, encender un LED)
    ; Aquí solo terminamos el programa
    MOV AX, 1
    INT 0x80

not_greater:
    ; Código si AX es menor o igual a BX
    ; (Por ejemplo, apagar un LED)
    ; Aquí solo terminamos el programa
    MOV AX, 1
    INT 0x80

Retroalimentación y Consejos

  • Error Común: Olvidar que las instrucciones de comparación no modifican los registros, solo las banderas.
  • Consejo: Siempre asegúrate de que las etiquetas (labels) sean únicas y descriptivas para evitar confusiones en el flujo del programa.

Conclusión

Las sentencias condicionales en ensamblador son esenciales para controlar el flujo del programa. Comprender cómo funcionan las comparaciones y los saltos condicionales te permitirá escribir programas más complejos y eficientes. En el próximo tema, exploraremos los bucles e iteraciones, que son fundamentales para repetir bloques de código de manera controlada.

© Copyright 2024. Todos los derechos reservados