Introducción

El lenguaje ensamblador MIPS es utilizado para programar microprocesadores de la arquitectura MIPS (Microprocessor without Interlocked Pipeline Stages). Esta arquitectura es conocida por su simplicidad y eficiencia, y es ampliamente utilizada en la educación para enseñar conceptos de arquitectura de computadoras y programación en ensamblador.

Objetivos del Módulo

  • Comprender la arquitectura MIPS y su conjunto de instrucciones.
  • Aprender la sintaxis y estructura básica del ensamblador MIPS.
  • Escribir y ejecutar programas simples en ensamblador MIPS.
  • Utilizar herramientas de desarrollo y simulación para MIPS.

Arquitectura MIPS

Características Principales

  • RISC (Reduced Instruction Set Computer): MIPS es una arquitectura RISC, lo que significa que tiene un conjunto reducido de instrucciones, cada una de las cuales realiza una operación simple.
  • Registros: MIPS tiene 32 registros de propósito general, cada uno de 32 bits.
  • Pipeline: La arquitectura MIPS utiliza un pipeline para mejorar el rendimiento, permitiendo que múltiples instrucciones se procesen simultáneamente en diferentes etapas.

Registros en MIPS

Registro Nombre Uso
$zero Zero Siempre contiene el valor 0
$at Assembler Temporary Reservado para el ensamblador
$v0-$v1 Values Valores de retorno de funciones
$a0-$a3 Arguments Argumentos de funciones
$t0-$t7 Temporaries Variables temporales
$s0-$s7 Saved Temporaries Variables temporales guardadas
$t8-$t9 More Temporaries Más variables temporales
$k0-$k1 Kernel Reservados para el sistema operativo
$gp Global Pointer Puntero global
$sp Stack Pointer Puntero de pila
$fp Frame Pointer Puntero de marco
$ra Return Address Dirección de retorno

Sintaxis y Estructura Básica

Formato de Instrucción

Las instrucciones en MIPS tienen un formato simple y se dividen en tres tipos principales: R, I y J.

Tipo R (Registro)

opcode rs rt rd shamt funct
  • opcode: Código de operación (6 bits)
  • rs: Registro fuente 1 (5 bits)
  • rt: Registro fuente 2 (5 bits)
  • rd: Registro destino (5 bits)
  • shamt: Shift amount (5 bits)
  • funct: Función específica (6 bits)

Tipo I (Inmediato)

opcode rs rt immediate
  • opcode: Código de operación (6 bits)
  • rs: Registro fuente (5 bits)
  • rt: Registro destino (5 bits)
  • immediate: Valor inmediato (16 bits)

Tipo J (Salto)

opcode address
  • opcode: Código de operación (6 bits)
  • address: Dirección de salto (26 bits)

Ejemplo de Programa Simple

A continuación, se muestra un programa simple en ensamblador MIPS que suma dos números y almacena el resultado en un registro.

.data
num1: .word 5
num2: .word 10
result: .word 0

.text
main:
    lw $t0, num1       # Cargar num1 en $t0
    lw $t1, num2       # Cargar num2 en $t1
    add $t2, $t0, $t1  # Sumar $t0 y $t1, almacenar en $t2
    sw $t2, result     # Almacenar el resultado en 'result'
    li $v0, 10         # Código de salida
    syscall            # Llamada al sistema para terminar el programa

Explicación del Código

  1. Segmento de Datos:

    • .data: Indica el inicio de la sección de datos.
    • num1, num2, result: Definición de variables y sus valores iniciales.
  2. Segmento de Texto:

    • .text: Indica el inicio de la sección de código.
    • main: Etiqueta que marca el inicio del programa principal.
    • lw $t0, num1: Carga el valor de num1 en el registro $t0.
    • lw $t1, num2: Carga el valor de num2 en el registro $t1.
    • add $t2, $t0, $t1: Suma los valores de $t0 y $t1, y almacena el resultado en $t2.
    • sw $t2, result: Almacena el valor de $t2 en la variable result.
    • li $v0, 10: Carga el código de salida en el registro $v0.
    • syscall: Realiza una llamada al sistema para terminar el programa.

Ejercicios Prácticos

Ejercicio 1: Multiplicación de Dos Números

Escribe un programa en ensamblador MIPS que multiplique dos números y almacene el resultado en una variable.

Solución

.data
num1: .word 4
num2: .word 3
result: .word 0

.text
main:
    lw $t0, num1       # Cargar num1 en $t0
    lw $t1, num2       # Cargar num2 en $t1
    mul $t2, $t0, $t1  # Multiplicar $t0 y $t1, almacenar en $t2
    sw $t2, result     # Almacenar el resultado en 'result'
    li $v0, 10         # Código de salida
    syscall            # Llamada al sistema para terminar el programa

Ejercicio 2: Comparación de Dos Números

Escribe un programa en ensamblador MIPS que compare dos números y almacene el mayor en una variable.

Solución

.data
num1: .word 7
num2: .word 5
max: .word 0

.text
main:
    lw $t0, num1       # Cargar num1 en $t0
    lw $t1, num2       # Cargar num2 en $t1
    bgt $t0, $t1, store_t0  # Si $t0 > $t1, saltar a store_t0
    sw $t1, max        # Almacenar $t1 en 'max'
    j end              # Saltar a end
store_t0:
    sw $t0, max        # Almacenar $t0 en 'max'
end:
    li $v0, 10         # Código de salida
    syscall            # Llamada al sistema para terminar el programa

Conclusión

En este módulo, hemos explorado la arquitectura MIPS y su conjunto de instrucciones, aprendiendo a escribir programas simples en ensamblador MIPS. Hemos cubierto la sintaxis básica y la estructura de las instrucciones, así como la utilización de registros y operaciones aritméticas. Los ejercicios prácticos proporcionan una base sólida para continuar explorando y desarrollando habilidades en programación en ensamblador MIPS.

En el próximo módulo, profundizaremos en la programación en ensamblador para otras arquitecturas, como ARM, y compararemos sus características y diferencias con MIPS.

© Copyright 2024. Todos los derechos reservados