======================================================================
Esta es la documentación para compilar y ejecutar programas en LRV32IM
======================================================================

Se está ejecutando el comando: less README.txt

   ***************************
   *** Para salir: tecla q ***
   ***************************

Para avanzar a una nueva página: tecla <page down>
Para retroceder a la página anterior: tecla <page up>
Para avanzar una sola línea: tecla <enter>
Para buscar un texto: tecla / seguido del texto (/...texto...)

-----------------------------------------------

Las instrucciones están en el enunciado de la pregunta 3.i

-----------------------------------------------

(Desde acá en adelante no es relevante para contestar el examen)

Programas disponibles para compilar y ejecutar:

clase.S : ejemplo de ejecucion de add, sb y bge
ifact.c : calcula el factorial en formato int
rfact.c : calcula el factorial en formato double, pero se demora una hora
          en mostrar el resultado

Los programas pueden ejecutarse en Linux con qemu-riscv32 o en Logisim bajo
LRV32IM.

-----------------------------------------------

Como probar en LRV32IM, por ejemplo clase.S o ifact.c:

make clase.ram

Luego abrir logisim y cargar lrv32im-v1.circ, entrar al modulo RAM, seleccionar
la componente de memoria RAM, abrir menu con boton derecho y seleccionar
la opcion cargar imagen.  Se abre un panel que permite seleccionar un archivo.
Navegue hasta encontrar el archivo clase.ram y abralo.
A continuacion regrese al modulo cpu y seleccione el menu Simular -> Activar
reloj (o control-K).  La salida se observa en "Ascii Display".  Para la
entrada, seleccione con la mano "Keyboard" e ingrese un texto.
Si el programa esta leyendo, aparecera en el display, si no, quedara
encolado en keyboard a la espera de que el programa lo lea.

Si necesitan volver a ejecutar, deben resetear con Simular -> Resetear
simulacion.  Esto borra la RAM.  Deben volver a cargar la imagen del programa
(por ejemplo clase.ram) en la memoria.  Y solo despues rejecutar con control-K.

La ejecucion se detiene si el programa lee la direccion ingresada en
rdwatch del modulo debugger o si se escribe en la direccion ingresada en
wrwatch.  Si le ocurre puede retomar la ejecucion colocando un 1 en la entrada
cont de debugger.

Tambien puede ejecutar paso a paso las instrucciones con Simular -> Conmutar
reloj (o control-T).  Para saber que instruccion se esta ejecutando fijese
en la direccion marcada abajo en el tunel PC.  Digamos que es 0x10150.
En el terminal ejecute por ejemplo "make clase.ddd-l".  Eso abrira ddd
del archivo binario ejecutable del programa clase.s.  Para ver que
instrucciones se van a ejecutar, ingrese en ddd:

x/20i 0x10150

Eso mostrara en assembler las siguientes 20 instrucciones.

No intente ejecutar esos binario con cont.  Caera en un seg. fault muy pronto
porque con ese binario el display y keyboard no son accesibles.  Pero
si no se accede al display o keyboard, se podra ejecutar, pero no vera
los resultados en ningun lado.

-----------------------------------------------

Como compilar y ejecutar para qemu-riscv32:

Para probar los mismos programas con el emulador qemu-riscv32 hay varias
opciones, ejecutando estos comandos en el terminal:

make ifact.run-O

Compila el programa con opciones de optimizacion y lo ejecuta directamente
en el terminal.

make ifact.ddd-g

Compila el programa con opciones de depuracion, lanza ddd para depurar el
programa y lanza el programa de manera que la ejecucion se pueda depurar
con ddd.  Defina los breakpoints que necesite y comience la ejecucion con
el comando cont en ddd.

Los binarios para qemu recurren a otra implementacion de la entrada/salida,
haciendo que funciones como showStr, muestren efectivamente en la salida
estandar de Linux.  Esta implementacion esta en term-qemu.c.  Para los
binarios que se ejecutaran con LRV32IM, la implementacion esta en term.c.

Si necesita reejecutar el programa, porque por ejemplo hizo cambios
en el programa fuente, no vuelva a invocar make ifact.ddd-g
porque perdera los breakpoints.  Mate el programa actualmente en ejecucion
ingresando en ddd: kill
Luego invoque en el terminal: make ifact.rerun-g
y en ddd: target remote localhost:1234
y luego: cont

ddd no es perfecto y a veces se cae.  Ahi no queda otra que relanzarlo.
El problema es que a veces el emulador sigue corriendo ocupando
localhost:1234 y no se puede volver a probar otro programa.  Si le ocurre,
ejecute este comando en un terminal:

ps a | grep qemu-riscv32

Si la salida es por ejemplo:

 4294 pts/2    Sl+    0:00 qemu-riscv32 ifact.qemu-O
 4301 pts/3    S+     0:00 grep qemu-riscv32

El proceso que tiene tomado localhost:1234 es el 4294.  Matelo con:

kill -9 4294

Ahora podra volver a probar programas con ddd y qemu.

-----------------------------------------------

Ud. puede crear sus propios programas y probarlos con LRV32IM y/o qemu,
siempre y cuando la entrada y salida se limite a llamar a las funciones
declaradas en term.h.  Por ejemplo si creo miprog.c, tiene todas estas
opciones para probar:

make miprog.ram
make miprog.run-O
make miprog.ddd-g  (y opcionalmente make miprog.rerun-g)

-----------------------------------------------

Para ver el assembler generado por gcc para un programa en c:

make ifact.s

(Compila con opciones de optimizacion)

-----------------------------------------------

Para recompilar el programa que genera el u-codigo con las señales de control:

make ucode.rom

Debe cargar el archivo ucode.rom en la ROM ubicada en el modulo Control Unit
(cu2).  Para cargarlo, opere de la misma manera que cargo el archivo .ram
en la memoria RAM.  Como es una ROM, no se pierde su contenido cuando
resetea la simulacion, pero si preservar su contenido para la proxima
vez que cargue LRV32IM, debe grabar el circuito.

-----------------------------------------------

Para hacer limpieza y borrar todos los archivos generados:

make clean

De todas formas esos archivos se puede reconstruir con: make archivo
