SmartEng Tools

RISC-V · Ejecución

Laboratorio del depurador RISC-V

Desde el punto de vista del programador, un procesador RV32I es un estado: 32 registros de 32 bits y un contador de programa (PC). Cada instrucción lee parte de ese estado y modifica otra parte. El depurador ejecuta tu código una instrucción cada vez para que veas exactamente qué cambia.

Cómo leer la pantalla

  • PC es la dirección de la siguiente instrucción que se va a ejecutar. El programa empieza en 0x00000000 y cada instrucción ocupa 4 bytes, así que la línea marcada con ▶ está en la dirección PC.
  • Cada registro muestra su valor en decimal con signo y en hexadecimal. El que cambió en el último paso aparece resaltado.
  • «Paso» ejecuta una instrucción; «Ejecutar» sigue hasta el final (o hasta 10 000 instrucciones, para detener bucles infinitos). Editar el código reinicia el estado.
  • La tabla de etiquetas muestra la dirección que corresponde a cada etiqueta: es el destino de los saltos.

Depurador

PC = 0x000000000 instrucciones ejecutadasSiguiente: línea 2

Logs de Ejecución

No hay logs de ejecución todavía.

Banco de Registros

x0zero00x00000000
x1ra00x00000000
x2sp00x00000000
x3gp00x00000000
x4tp00x00000000
x5t000x00000000
x6t100x00000000
x7t200x00000000
x8s000x00000000
x9s100x00000000
x10a000x00000000
x11a100x00000000
x12a200x00000000
x13a300x00000000
x14a400x00000000
x15a500x00000000
x16a600x00000000
x17a700x00000000
x18s200x00000000
x19s300x00000000
x20s400x00000000
x21s500x00000000
x22s600x00000000
x23s700x00000000
x24s800x00000000
x25s900x00000000
x26s1000x00000000
x27s1100x00000000
x28t300x00000000
x29t400x00000000
x30t500x00000000
x31t600x00000000

Etiquetas

  • loop:0x0000000C

Admite add, sub, and, or, xor, sll, srl, sra, slt, sltu, sus versiones con inmediato, lui, auipc, saltos condicionales (beq, bne, blt, bge, bltu, bgeu), jal, jalr y las pseudoinstrucciones nop, li, mv, not, neg, j, jr, ret, beqz y bnez. No hay memoria de datos: lw, sw y el resto de accesos a memoria no están implementados. El programa empieza en la dirección 0x00000000 y cada instrucción ocupa 4 bytes.

Ejercicios del laboratorio

Resuelve cada uno a mano antes de ejecutarlo. «Abrir en la herramienta» carga el programa en el depurador para que compruebes cada paso.

Ejercicio 1 · Registros y el registro zero

Tu primer programa

Dos instrucciones cargan constantes y la tercera las suma. ¿Qué valor queda en a0?

addi t0, zero, 5
addi t1, zero, 7
add  a0, t0, t1
Abrir en la herramienta

Ejercicio 2 · El PC y los saltos incondicionales

Un salto incondicional cambia el PC

¿Cuánto vale a0 al terminar y cuántas instrucciones se ejecutan?

li   a0, 1
j    skip
li   a0, 2
skip:
  addi a0, a0, 10
Abrir en la herramienta

Ejercicio 3 · Bucles con saltos condicionales

Sigue la ejecución de un bucle

¿Cuánto vale a0 al salir del bucle? ¿Cuántas instrucciones se ejecutan en total (contando cada vuelta)?

li   a0, 1
li   t0, 4
loop:
  add  a0, a0, a0
  addi t0, t0, -1
  bnez t0, loop
Abrir en la herramienta

Ejercicio 4 · Aritmética de 32 bits

Desbordamiento en complemento a dos

lui carga 0x80000 en los 20 bits altos de t0. ¿Qué valen t1 y t2 en decimal?

lui  t0, 0x80000
addi t1, t0, -1
slt  t2, t1, t0
Abrir en la herramienta

Ejercicio 5 · Llamadas a funciones

Llamar a una función con jal y volver con ret

La rutina triple recibe un número en a0 y devuelve el resultado en a0. ¿Qué valen a0 y ra al terminar?

li   a0, 6
jal  ra, triple
j    end
triple:
  add  a1, a0, a0
  add  a0, a1, a0
  ret
end:
  nop
Abrir en la herramienta

Qué modela el intérprete

  • Aritmética y lógica: add, sub, and, or, xor, sll, srl, sra, slt, sltu y sus versiones con inmediato (addi, andi, ori, xori, slti, sltiu, slli, srli, srai). Los resultados se truncan a 32 bits en complemento a dos, sin excepciones por desbordamiento.
  • lui y auipc, saltos condicionales (beq, bne, blt, bge, bltu, bgeu) hacia etiquetas, jal y jalr.
  • Pseudoinstrucciones: nop, li (inmediato de 12 bits), mv, not, neg, j, jr, ret, beqz y bnez, que se expanden a su instrucción base.
  • Escribir en x0 no tiene efecto: siempre vale 0.
GuíaDel código máquina al ensambladorTraduce una rutina completa con bucle, etiquetas y pseudoinstrucciones.HerramientaSimulador de pipelineLas mismas instrucciones, ahora solapadas en 5 etapas.

Referencias