• Tiempo: 115 minutos
• Descripción: Examen Parcial 1. Laboratorio. Grado en Ingeniería de Robótica Software
• Fecha: 2026/May/11
• Temario: Sesiones L9-L11

• Programa
• Solución al programa
• Autores
• Licencia
• Enlaces

Escribe un programa en RISC-V que pida una palabra al usuario y que la imprima por la consola lo siguiente:

• La primera línea debe contener la palabra entera insertando un espacio en blanco entre cada carácter.
• Cada siguiente línea ha de quitar el primer carácter a la palabra introducida por el usuario. Es decir, ha de formar una especie de triángulo.

Ejemplo de ejecución:

Introduzca una palabra (max 10 caracteres): **** user input : RISC-V
R I S C - V
 
I S C - V
 
S C - V
 
C - V
 
- V
 
V 

El programa escrito ha de cumplir las siguientes condiciones:

• Se ha de implementar todo el programa en un único fichero de nombre triangle.s, tanto el cuerpo principal como las subrutinas requeridas.
• Se ha de implementar con dos subrutinas recursivas.
  • Una que imprima una palabra (string) añadiendo los espacios entre las letras. La subrutina ha de llamarse line, recibe un parámetro con un puntero a la cadena a imprimir y no retorna nada
  • Otra que imprima el triángulo invocando a la función que imprime las palabras. La subrutina ha de llamarse triangle, recibe un parámetro con un puntero a la cadena a imprimir y no retorna nada
• El cuerpo principal del programa ha de pedir al usuario la palabra a tratar y posteriormente invocar a la subrutina que imprime el triángulo
• El tamaño de palabra máximo que puede introducir el usuario es de 10 caracteres.
• A modo de guía, en python las funciones recursivas podrían ser como las siguientes:

def line(cad):
  if cad=="":
    return 
  else:
    print (cad[0] + " ")
    line (cad[1:])
    return

def triangle(cad):
    if cad=="":
      return 
    else:
      line(cad)
      triangle (cad[1:])
    return

Añade al programa anterior el código necesario para que mida dinámicamente el consumo de pila del mismo.

Para ello se ha de utilizar la librería adjunta que tiene las siguientes funciones:

• register_sp_source: se utiliza al inicio para registrar el valor base de referencia del puntero de pila. En a0 recibe la dirección de memoria del puntero
• register_sp_min: se utilizar para registrar el valor del puntero de pila en un momento dado. Se puede utilizar múltiples veces
• get_sp_diff: una vez terminado el muestreo, retorna el tamaño máximo en bytes registrado (con register_sp_min) respecto a la dirección base indicada en registre_sp_source

Recomendación para la implementación:

Implementa el programa paso a paso verificando cada trozo de funcionalidad.

Posibles pasos:

• Cuerpo principal del programa con petición de palabra de entrada
• Implementación de función "line". En caso de necesitar depuración usa palabras cortas.
• Implementación de función "triangle". En caso de necesitar depuración usa palabras cortas.
• Guarda el fichero y crea copia para seguir trabajando con ejercicio 2
• Registra puntero de pila antes de invocar a "triangle"
• Añade mensaje de salida incluyendo el tamaño consumido de pila
• Localiza las ubicaciones donde se añaden datos a la pila e implementa las llamadas a register_sp_min

Otras consideraciones:

• Es necesario respetar ABI de RISC-V, especialmente con el manejo de los registros

Entrega

• Fichero triangle.s con la implementación de los dos ejercicios, en caso de que el segundo no esté completo, entregar con la implementación del primero y triangle_ej2.s con la implementación parcial del segundo

#Recursive triangle

	.include "servicios.asm"
	.eqv WORD_SIZE 11
	.data

wmsg:	.string "Introduzca una palabra (max 10 caracteres): "
inputword: .space WORD_SIZE

spmsg:	.string "El tamaño máximo de pila utilizado (en bytes): "	


	
	.text
	
	mv a0, sp
	jal register_sp_source
	
	la a0, wmsg
	li a7, PRINT_STRING
	ecall
	
	la a0, inputword
	li a1, WORD_SIZE
	li a7, READ_STRING
	ecall

	jal triangle
	
	la a0, spmsg
	li a7, PRINT_STRING
	ecall
	

	jal get_sp_diff
	
	li a7, PRINT_INT
	ecall
	
	li a7, EXIT
	ecall	
	
#=====================================================

#recursive line
#input
#a0: string
#output:
#a0: stack address


line:
	addi sp, sp, -16
	sw ra, 12(sp)
	sw a0, 8(sp) #guarda argumento de entrada

	mv a0, sp
	jal register_sp_min
	
	lw t1, 8(sp)
	lb t0, 0(t1)
	beqz t0, line_end

	

		
	
	
	mv a0, t0
	li a7, PRINT_CHAR
	ecall

	li a0, ' '
	li a7, PRINT_CHAR
	ecall


	lw a0, 8(sp)
	addi a0, a0, 1
	jal line 
	
	

line_end:	
	lw ra, 12(sp)
	addi sp, sp, 16
	ret

#====================
# Prints an string in a triangle recursively
# example for "man":
# man
# an
# n
#input:
# a0: string

triangle:

	addi sp, sp, -16
	sw ra, 12(sp)
	sw a0, 8(sp)


	mv a0, sp
	jal register_sp_min


	lw t1, 8(sp)
	lb t0, 0(t1)
	beqz t0, triangle_end
	
	mv a0, t1				
	jal line
	
	li a0,'\n'
	li a7, PRINT_CHAR
	ecall
	
	lw a0, 8(sp)
	addi a0, a0, 1
	jal triangle


triangle_end:
	lw ra,12(sp)
	addi sp, sp, 16
	ret

• Juan Ignacio Pérez
• Miguel Ángel de Miguel
• Juan González-Gómez (Obijuan)

• Documentación de la ABI del RISCV
• Simulador RARS, en github
• Universidad Rey Juan Carlos de Madrid
• Escuela Técnica Superior de Ingeniería de Telecomunicaciones (URJC)