1. Rewrite your program in #1 to use a procedure for the conversion. In other words, if you send ‘a' to the procedure it will return ‘A'. Leave the rest of the code in main. Test it on the source strings: "loop2:" and "Elephant!" You should print two memory screen shots, one for each input data.
In your procedure you should add code to check if the byte sent to the procedure is in fact a lowercase letter, and only convert if it is; otherwise it should just return the byte.
In the program for problem 1 you could use $tn registers but in this program you should follow the conventions for using $sn and $tn registers.
Also, use the directive .space for the second string, reserving at least 25 bytes.
This is my code:
.data
in_string: .asciiz "Input your string please:\n"
out_msg: .asciiz "Uppercase of your strings are:\n"
in_name:
.space 25 # space for input string
.text
.globl main
main: la $a0,in_string # prompt user for input
li $v0,4
syscall
la $a0,in_name # read the input string
li $a1,25
li $v0,8
syscall
la $a0,out_msg # write output message
li $v0,4
syscall
la $t0,in_name
loop:
lb $s1,($t0)
beqz $s1,exit_loop # if NULL, we are done
blt $s1,'a',lowercase_Var
bgt $s1,'z',lowercase_Var
addu $s1,$s1,-32 # convert to uppercase
lowercase_Var:
sb $s1,($t0)
addu $t0,$t0,1 # increment pointer
j loop
exit_loop:
la $a0,in_name # output converted string
li $v0,4
syscall
li $v0,10 # exit
syscall
2. We don't have to save $s0 and $s1 in our procedure because we didn't use them. However, to observe the process, go ahead and add statements at the top of the procedure to save $s0 and $s1 on the stack and statements at the bottom of the procedure to restore them. Single-step through your program (at least through the first subroutine call) and answer the following questions. Copy a-g below and paste your answers/screen shot here.
a. Single-step to the jal statement. Write down the contents of registers:
• $sp=
• $pc=
• $ra =
b. Single-step over the jal. Write the down the contents of registers:
• $ra=
• $pc=
c. Single-step over the instructions that save $s0, $s1 on the stack. Change the memory window to look at the current $sp, uncheck ASCII if you have it checked. Take a screen shot showing the stack and the current $sp
d. Single-step through the procedure, through the statements that restore $s0 and $s1. Write down the contents of registers:
• $sp =
• $pc =
e. Single-step back to the calling procedure. Write down the contents of registers:
• $sp =
• $pc =
• $ra =
f. Write a 3-4 sentence summary of how the $pc and $ra registers are affected by subroutine calls and returns.
g. Write a 4-6 sentence summary describing the (i) the convention of saving $sn registers at the top of the subroutine and restoring them at the end (ii) how registers are stored/restored on the stack and how the $sp is affected, (iii) what the stack looks like after you return from a subroutine. Is the data pushed onto the stack still there? Where does the $sp point?