Lenguaje ensamblador - Condicionales

La sentencia condicional es la piedra angular del flujo de control de un programa. El lenguaje ensamblador implementa lógica de decisión como if-else, switch, etc., mediante instrucciones de comparación y salto condicional.


CMP - Instrucción de comparación

CMPRealiza una resta entre dos operandos (destino - origen), pero no guarda el resultado, solo actualiza las banderas.

En esenciaCMP dest, srcEs equivalente aSUB dest, srcPero descarta el resultado del cálculo.

Ejemplo

; Ejemplo de la instrucción de comparación CMP

section .text
    global _start

_start:
    mov eax, 10
    cmp eax, 10                 ; eax == 10?
    ; ZF = 1 (igual, resultado cero)
    ; CF = 0 (sin préstamo)
    ; SF = 0 (resultado no negativo)

    mov eax, 5
    cmp eax, 10                 ; eax == 10?
    ; ZF = 0 (desigual, resultado distinto de cero)
    ; CF = 1 (hay préstamo: 5 < 10)

    mov eax, 20
    cmp eax, 10                 ; eax == 10?
    ; ZF = 0 (desigual)
    ; CF = 0 (sin préstamo: 20 >= 10)
    ; SF = 0 (resultado no negativo: 10 > 0)

    mov eax, 1
    mov ebx, 0
    int 0x80

Instrucciones de salto condicional

Las instrucciones de salto condicional deciden si saltar según el estado de las banderas. Si la condición se cumple, saltan a la etiqueta de destino; de lo contrario, continúan con la siguiente instrucción.

InstrucciónSignificadoBanderas comprobadasCaso de uso
JE / JZSaltar si igual / si es ceroZF = 1cmp a, bComprobar a == b después
JNE / JNZSaltar si no es igual / si no es ceroZF = 0cmp a, bComprobar a != b después
JG / JNLESaltar si es mayor (con signo)ZF=0 y SF=OFa > b con signo
JGE / JNLSaltar si es mayor o igual (con signo)SF = OFa >= b con signo
JL / JNGESaltar si es menor (con signo)SF != OFa < b con signo
JLE / JNGSaltar si es menor o igual (con signo)ZF=1 o SF!=OFa <= b con signo
JA / JNBESaltar si es mayor (sin signo)CF=0 y ZF=0a > b sin signo
JAE / JNBSaltar si es mayor o igual (sin signo)CF = 0a >= b sin signo
JB / JNAESaltar si es menor (sin signo)CF = 1a < b sin signo
JBE / JNASaltar si es menor o igual (sin signo)CF=1 o ZF=1a <= b sin signo

Muchas instrucciones tienen dos alias (como JE y JZ), que son exactamente iguales a nivel de código de máquina. Cuál usar depende del contexto: después de una comparación se usa JE/JNE; después de comprobar el resultado de una operación se usa JZ/JNZ. Así el código es más legible.


Estructura IF de una sola rama

Ejemplo

; Ruta del archivo: if_demo.asm
; Implementación: if (x > 10) x = 10;

section .data
    x dd 15                     ; Valor de prueba
    limit dd 10

section .text
    global _start

_start:
    mov eax, [x]                ; Cargar x en eax
    cmp eax, [limit]            ; x > 10 ?
    jle skip_update             ; Si x <= 10, omitir la actualización

    mov dword [x], 10           ; x = 10

skip_update:
    ; El programa continúa... (aquí x ya es 10)

    mov eax, 1
    mov ebx, 0
    int 0x80

Estructura IF-ELSE de dos ramas

Ejemplo

; Ruta del archivo: if_else_demo.asm
; Implementación: if (score >= 60) grade = 'P' else grade = 'F'

section .data
    score dd 75                 ; Puntuación del examen
    grade db 0                  ; Calificación
    PASS_SCORE equ 60

section .text
    global _start

_start:
    mov eax, [score]            ; Cargar la puntuación
    cmp eax, PASS_SCORE         ; score >= 60 ?
    jge pass_label              ; Si >= 60, saltar a pass

    ; Rama else: suspenso
    mov byte [grade], 'F'       ; grade = 'F'
    jmp end_if                  ; Omitir la rama if

pass_label:
    ; Rama if: aprobado
    mov byte [grade], 'P'       ; grade = 'P'

end_if:
    ; La variable grade ya está configurada

    ; Imprimir la calificación
    mov eax, 4
    mov ebx, 1
    mov ecx, grade
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Resultado de la ejecución:

$ nasm -f elf32 if_else_demo.asm -o if_else_demo.o
$ ld -m elf_i386 if_else_demo.o -o if_else_demo
$ ./if_else_demo
P

Estructura IF-ELSE IF-ELSE de múltiples ramas

A continuación, usando un sistema de calificación por puntuación como ejemplo, se muestra el flujo de la decisión de múltiples ramas:

条件判断多分支流程图

Ejemplo

; Ruta del archivo: multi_branch.asm
; Calificación por puntuación: >=90 -> A, >=80 -> B, >=70 -> C, >=60 -> D, <60 -> F

section .data
    score dd 85
    result db 0
    newline db 0xA

section .text
    global _start

_start:
    mov eax, [score]            ; Cargar la puntuación

    ; Comprobar >= 90
    cmp eax, 90
    jl check_80                 ; Si < 90, continuar comprobando
    mov byte [result], 'A'
    jmp print_result

check_80:
    cmp eax, 80
    jl check_70
    mov byte [result], 'B'
    jmp print_result

check_70:
    cmp eax, 70
    jl check_60
    mov byte [result], 'C'
    jmp print_result

check_60:
    cmp eax, 60
    jl fail_label
    mov byte [result], 'D'
    jmp print_result

fail_label:
    mov byte [result], 'F'

print_result:
    ; Imprimir la calificación
    mov eax, 4
    mov ebx, 1
    mov ecx, result
    mov edx, 1
    int 0x80

    ; Imprimir nueva línea
    mov eax, 4
    mov ebx, 1
    mov ecx, newline
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

TEST - Instrucción de prueba no destructiva

TESTRealiza un AND bit a bit pero no guarda el resultado, solo actualiza las banderas.

TESTA menudo se usa para comprobar si un bit específico es 1, o si un registro es 0.

Ejemplo

; Ejemplo de la instrucción TEST

    ; Comprobar si eax es 0 (más eficiente que CMP eax, 0)
    test eax, eax               ; eax & eax = eax, solo actualiza ZF
    jz  eax_is_zero             ; Si ZF=1, significa que eax=0

    ; Comprobar un bit específico
    test al, 0x01               ; Comprobar si bit0 es 1
    jnz bit0_is_set             ; Si bit0=1, saltar

    ; Comprobar múltiples bits
    test al, 0x03               ; Comprobar si al menos uno de bit0 y bit1 es 1
    jnz some_bit_set

SETcc - Instrucción de establecimiento condicional

No salta, sino que establece el byte de destino a 1 o 0 según la condición:

Ejemplo

; Ejemplo de establecimiento condicional SETcc

    ; Guardar el resultado de a > b en al
    mov eax, 10
    cmp eax, 5                  ; 10 > 5 ?
    setg al                     ; al = 1 (si se cumple mayor)
    ; Si eax = 3, entonces al = 0

    ; Otras instrucciones SETcc:
    ; sete / setz -> igual / cero
    ; setne / setnz -> desigual / no cero
    ; setl -> menor que (con signo)
    ; setb -> menor que (sin signo)
    ; setg -> mayor que (con signo)
    ; seta -> mayor que (sin signo)

Ejemplo completo: determinar paridad y signo

Ejemplo

; Ruta del archivo: number_check.asm
; Determinar paridad y signo del número

section .data
    number dd -42
    msg_even db 'Even', 0xA
    msg_even_len equ $ - msg_even
    msg_odd db 'Odd', 0xA
    msg_odd_len equ $ - msg_odd
    msg_pos db 'Positive', 0xA
    msg_pos_len equ $ - msg_pos
    msg_neg db 'Negative', 0xA
    msg_neg_len equ $ - msg_neg
    msg_zero db 'Zero', 0xA
    msg_zero_len equ $ - msg_zero

section .text
    global _start

_start:
    mov eax, [number]

    ; Comprobar si es 0
    cmp eax, 0
    jne check_sign
    ; Es cero
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_zero
    mov edx, msg_zero_len
    int 0x80
    jmp exit

check_sign:
    ; Determinar signo
    cmp eax, 0
    jg  is_positive             ; eax > 0

    ; Negativo
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_neg
    mov edx, msg_neg_len
    int 0x80
    jmp check_parity

is_positive:
    ; Positivo
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_pos
    mov edx, msg_pos_len
    int 0x80

check_parity:
    ; Determinar paridad (solo hay que mirar el bit menos significativo)
    mov eax, [number]
    test eax, 1                 ; Comprobar bit0
    jnz is_odd

    ; Par
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_even
    mov edx, msg_even_len
    int 0x80
    jmp exit

is_odd:
    ; Impar
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_odd
    mov edx, msg_odd_len
    int 0x80

exit:
    mov eax, 1
    mov ebx, 0
    int 0x80

Las instrucciones de salto condicional solo pueden saltar a etiquetas dentro del segmento de código actual; el rango de salto suele estar limitado entre aproximadamente 128 bytes (salto corto) y 2 GB (salto cercano). NASM elige automáticamente la codificación de salto adecuada.

Otras extensiones