Llegamos a la última frontera en larebelion.com. Si has sobrevivido a la programación en C, a la gestión de memoria y a los Sockets, es hora de hablar directamente con el procesador. Bienvenidos a Arquitectura de Computadores.
En las universidades españolas, normalmente se enseña Ensamblador usando MIPS (con simuladores como MARS o SPIM) o x86 (usando NASM en Linux). En este post, hemos recopilado 10 ejercicios de exámenes de ambos mundos para que domines los registros, los saltos condicionales y las llamadas al sistema (syscalls).
1. MIPS: Suma de dos enteros (UPM)
Enunciado: Escribe un programa en ensamblador MIPS que cargue dos números enteros en registros, los sume y guarde el resultado en un tercer registro.
.text
.globl main
main:
li $t0, 15 # Cargar el valor inmediato 15 en $t0
li $t1, 20 # Cargar el valor inmediato 20 en $t1
add $t2, $t0, $t1 # $t2 = $t0 + $t1 (15 + 20 = 35)
# Terminar el programa limpiamente
li $v0, 10 # Syscall 10 = exit
syscall
2. x86 (NASM): Imprimir "Hola Mundo" (UPC)
Enunciado: Crea el clásico "Hola Mundo" en ensamblador x86 de 32 bits para Linux, usando interrupciones de sistema (int 0x80).
section .data
msg db 'Hola Mundo', 0xA ; Mensaje con salto de línea
len equ $ - msg ; Longitud del mensaje
section .text
global _start
_start:
mov eax, 4 ; Syscall 4 = sys_write
mov ebx, 1 ; File descriptor 1 = stdout
mov ecx, msg ; Puntero a la cadena
mov edx, len ; Tamaño de la cadena
int 0x80 ; Llamada al kernel de Linux
mov eax, 1 ; Syscall 1 = sys_exit
int 0x80
3. MIPS: Condicional IF-ELSE (UCM)
Enunciado: Dado un valor en $t0, si es mayor o igual a 5, almacena un 1 en $t1 (aprobado), si no, almacena un 0 (suspenso).
.text
main:
li $t0, 4 # Nota del alumno
bge $t0, 5, aprobado # Branch if Greater or Equal to 5
suspenso:
li $t1, 0 # Cargar 0 (suspenso)
j fin # Salto incondicional a 'fin'
aprobado:
li $t1, 1 # Cargar 1 (aprobado)
fin:
li $v0, 10
syscall
4. x86 (NASM): Bucle FOR simple (UGR)
Enunciado: Escribe un bucle en ensamblador x86 que simule un for(int i=5; i>0; i--) utilizando la instrucción loop y el registro ecx.
section .text
global _start
_start:
mov ecx, 5 ; ecx es el contador del bucle
mov eax, 0 ; eax será el acumulador
mi_bucle:
add eax, 1 ; Operación interna del bucle
loop mi_bucle ; Decrementa ecx y salta si ecx != 0
mov eax, 1
int 0x80
5. MIPS: Recorrer un Array (US)
Enunciado: Tienes un array de 3 enteros en memoria. Escribe el código MIPS para sumar todos sus elementos y guardar el total en $t2.
.data
array: .word 10, 20, 30
.text
main:
la $t0, array # Cargar dirección base del array
li $t2, 0 # Inicializar suma total a 0
lw $t1, 0($t0) # Leer primer elemento
add $t2, $t2, $t1
lw $t1, 4($t0) # Leer segundo elemento (+4 bytes)
add $t2, $t2, $t1
lw $t1, 8($t0) # Leer tercer elemento (+8 bytes)
add $t2, $t2, $t1
li $v0, 10
syscall
6. x86 (NASM): Operaciones a nivel de Bits (UV)
Enunciado: Usa máscaras y operaciones bit a bit (AND, OR, XOR) para poner a cero el registro eax, encender su bit menos significativo y luego invertirlo.
section .text
global _start
_start:
xor eax, eax ; Forma eficiente de poner eax a 0
or eax, 1 ; Enciende el bit menos significativo (eax = 1)
not eax ; Invierte todos los bits (Complemento a 1)
mov eax, 1
int 0x80
7. MIPS: Leer entero por teclado (UC3M)
Enunciado: Escribe un programa que pida al usuario por teclado su edad y la guarde en un registro utilizando las Syscalls de SPIM/MARS.
.text
main:
# Syscall 5 = Read Integer
li $v0, 5
syscall
# El entero leído queda guardado en $v0
move $t0, $v0 # Lo movemos a $t0 para protegerlo
li $v0, 10
syscall
8. x86 (NASM): Longitud de una Cadena (UAM)
Enunciado: Implementa el equivalente a strlen() de C en ensamblador x86, iterando hasta encontrar el byte nulo (0x00).
section .data
cadena db "Ingenieria", 0
section .text
global _start
_start:
mov esi, cadena ; Puntero al inicio de la cadena
xor ecx, ecx ; ecx = 0 (Contador)
contar:
cmp byte [esi], 0 ; ¿Es el fin de cadena (\0)?
je fin_conteo ; Si es cero, salta a fin
inc esi ; Avanza al siguiente carácter
inc ecx ; Incrementa el contador
jmp contar
fin_conteo:
; En ecx queda almacenada la longitud (10)
mov eax, 1
int 0x80
9. MIPS: Pila (Stack) y Funciones (UMA)
Enunciado: Muestra cómo guardar el registro de retorno $ra en la pila antes de hacer una llamada a una subrutina anidada, y cómo restaurarlo después.
.text
mi_funcion:
# Prólogo: Reservar espacio en la pila y guardar $ra
addi $sp, $sp, -4
sw $ra, 0($sp)
# [Cuerpo de la función aquí]
# Epílogo: Restaurar $ra y liberar pila
lw $ra, 0($sp)
addi $sp, $sp, 4
jr $ra # Jump Register (Retorno)
10. x86 (NASM): Multiplicación (UNED)
Enunciado: Multiplica el valor 10 por 5 usando la instrucción mul y guarda el resultado en una variable de memoria.
section .bss
resultado resb 4 ; Reserva 4 bytes para el resultado
section .text
global _start
_start:
mov eax, 10 ; eax siempre es uno de los operandos en mul
mov ebx, 5
mul ebx ; Multiplica eax por ebx. Resultado en edx:eax
mov [resultado], eax ; Guarda los 32 bits bajos en la variable
mov eax, 1
int 0x80
