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
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ón | Significado | Banderas comprobadas | Caso de uso |
|---|---|---|---|
| JE / JZ | Saltar si igual / si es cero | ZF = 1 | cmp a, bComprobar a == b después |
| JNE / JNZ | Saltar si no es igual / si no es cero | ZF = 0 | cmp a, bComprobar a != b después |
| JG / JNLE | Saltar si es mayor (con signo) | ZF=0 y SF=OF | a > b con signo |
| JGE / JNL | Saltar si es mayor o igual (con signo) | SF = OF | a >= b con signo |
| JL / JNGE | Saltar si es menor (con signo) | SF != OF | a < b con signo |
| JLE / JNG | Saltar si es menor o igual (con signo) | ZF=1 o SF!=OF | a <= b con signo |
| JA / JNBE | Saltar si es mayor (sin signo) | CF=0 y ZF=0 | a > b sin signo |
| JAE / JNB | Saltar si es mayor o igual (sin signo) | CF = 0 | a >= b sin signo |
| JB / JNAE | Saltar si es menor (sin signo) | CF = 1 | a < b sin signo |
| JBE / JNA | Saltar si es menor o igual (sin signo) | CF=1 o ZF=1 | a <= 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
; 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
; 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
; 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
; 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
; 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
; 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
Otras extensionesLas 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.