Comenzando con mips

Simulador MARS MIPS

El simulador MARS MIPS es un editor, ensamblador, simulador y depurador de lenguaje ensamblador para el procesador MIPS, desarrollado por Pete Sanderson y Kenneth Vollmar en la Universidad Estatal de Missouri (src).

Obtienes el MARS gratis aquí. En cuanto a la instalación de la versión 4.5, es posible que necesite el SDK de Java adecuado para su sistema desde aquí

Antes de ensamblar, el entorno de este simulador se puede dividir de manera simple a tres segmentos: el editor en la parte superior izquierda donde se escribe todo el código, el compilador/salida justo debajo del editor y la lista de registros que representan la “CPU” de nuestro programa. ingrese la descripción de la imagen aquí

Después de ensamblar (simplemente presionando F3) el entorno cambia, con dos nuevos segmentos tomando la posición del editor: el segmento de texto donde

i) cada línea de código ensamblador se borra de “pseudoinstrucciones” (hablaremos de ellas en un segundo) en la columna “básica” y

ii) el código de máquina para cada instrucción en la columna “código”,

y el segmento de datos donde podemos ver una representación de la memoria de un procesador con orden little-endian. ingrese la descripción de la imagen aquí

Después de ensamblar, podemos ejecutar nuestro código de una vez (F5) o paso a paso (F7), así como rebobinar la ejecución varios pasos hacia atrás (F8). ingrese la descripción de la imagen aquí

Ahora, veamos el código de ejemplo de arriba y expliquemos cada línea:

.text
.globl main
main:            #main function

li    $v0, 11    #11=system code for printing a character, $v0=register that gets the system code for printing as value
la    $a0, 'a'   #'a'=our example character, $a0=register that accepts the character for printing
syscall          #Call to the System to execute our instructions and print the character at the a0 register 

li $v0, 10       #11=system code for terminating, $v0=register that gets the system code for terminating (optional, but desirable)
syscall          #Call to the System to terminate the execution

MARS acepta y exporta archivos con el tipo de archivo .asm

Pero el código anterior imprime solo un carácter, ¿qué pasa con el buen “Hola mundo”? ¿Qué tal, no sé, agregar un número o algo así? Bueno, podemos cambiar un poco lo que teníamos solo por eso:

.data               #data section 
str: .asciiz "Hello world\n"  
number: .word 256
 
.text                 #code section 
.globl main 
main: 
li       $v0, 4                #system call for printing strings 
la       $a0, str              #loading our string from data section to the $a0 register
syscall  
       
la       $t0, number        #loading our number from data section to the $t0 register
lw       $s1, 0($t0)        #loading our number as a word to another register, $s1 

addi     $t2, $s1, 8         #adding our number ($s1) with 8 and leaving the sum to register $t2

sw       $t2, 0($t0)        #storing the sum of register $t2 as a word at the first place of $t0

li       $v0, 10               # system call for terminating the execution
syscall 

Antes de ilustrar los resultados a través de MARS, es necesario explicar un poco más acerca de estos comandos:

  • Las llamadas al sistema son un conjunto de servicios proporcionados desde el sistema operativo. Para usar una llamada al sistema, se necesita poner un código de llamada $v0 registrarse para la operación necesaria. Si una llamada al sistema tiene argumentos, estos se colocan en los registros $a0-$a2. Aquí están todas las llamadas al sistema.

  • li (carga inmediata) es una pseudo-instrucción (hablaremos de eso más tarde) que carga instantáneamente un registro con un valor. la (cargar dirección) es también una pseudo-instrucción que carga una dirección a un Registrarse. Con li $v0, 4 el registro $v0 ahora tiene 4 como valor, mientras que la $a0, str carga la cadena de str en el Registro $a0.

  • Una palabra es (por mucho que estemos hablando de MIPS) un 32 bits secuencia, siendo el bit 31 el bit más significativo y el bit 0 el bit menos significativo.

  • lw (palabra de carga) se transfiere de la memoria a un registro, mientras que sw (almacenar palabra) se transfiere de un registro a la memoria. con el lw comando $s1, 0($t0), cargamos en $s1 registrar el valor que fue en el LSB del registro $t0 (eso es lo que simboliza el 0 aquí, el desplazamiento de la palabra), también conocido como 256. $t0 aquí tiene la dirección, mientras que $s1 tiene el valor. sw $t2, 0($t0) hace todo lo contrario trabajo.

  • MARS usa el Little Endian, lo que significa que el LSB de una palabra es almacenado en la dirección de byte más pequeña de la memoria.

  • MIPS usa direcciones de byte, por lo que una dirección es aparte de su anterior y luego por 4.

Al ensamblar el código anterior, podemos comprender mejor cómo se intercambian la memoria y los registros, deshabilitando los “valores hexadecimales” del segmento de datos:

ingrese la descripción de la imagen aquí

o habilitando “ASCII” desde el Segmento de Datos:

ingrese la descripción de la imagen aquí

Comience así

$ java -jar Mars4_5.jar

Cree este archivo y guárdelo.

    .text
main:
    li    $s0,0x30
loop:
    move    $a0,$s0        # copy from s0 to a0
    
    li    $v0,11        # syscall with v0 = 11 will print out
    syscall            # one byte from a0 to the Run I/O window

    addi    $s0,$s0,3    # what happens if the constant is changed?
    
    li    $t0,0x5d
    bne    $s0,$t0,loop
    nop            # delay slot filler (just in case)

stop:    j    stop        # loop forever here
    nop            # delay slot filler (just in case)

Presione F3 para ensamblarlo y luego presione ejecutar. Ahora ha comenzado a compilar y ejecutar el código MIPS.

Instalación o Configuración

Instrucciones detalladas sobre cómo configurar o instalar mips.

QtSpim para ventanas

  1. descargue QtSpim desde aquí 32.6 MB
  2. instalarlo fácil instalación
  3. Cree su primer archivo ensamblado (.s) o use la muestra C:\Program Files (x86)\QtSpim\helloworld.s
  4. ejecute el programa desde el acceso directo del escritorio o C:\Program Files (x86)\QtSpim\QtSpim.exe

hay dos ventanas para el programa, la principal etiquetada como QtSpim, aquí puede ver el programa que está ejecutando (texto etiquetado), la memoria (datos etiquetados), los valores de los registros (etiquetados FP Regs para coma flotante e Int Regs para enteros) y el control para el simulador

la otra ventana etiquetada como consola es donde verá la salida e ingresará la entrada de su programa si hay alguna

  1. cargue el archivo usando Archivo -> Cargar archivo
  2. puede usar hacer clic en ejecutar (f5) para ver el resultado final o ir paso a paso (p10) para ver el estado del registro y la memoria mientras el programa se ejecuta para depurar