The code I'm working on takes in a string from the user in the form "X123" (not limited to 3 characters) where X can be any non-number character, and 123 can be any series of number characters. The code then strips the non-number, converts the number part to an int, adds 5, and prints the result.
.data
msgerror: .asciiz "The string does not contain valid digits."
input: .space 9
open: .asciiz "Enter a string:\n"
close: .asciiz "The value +5 is:\n"
.text
.globl main
main:
li $v0, 4
la $a0, open
syscall
li $v0, 8
la $a0, input #read a string into a0
move $t0, $a0
syscall
li $t3,0
li $t4,9
la $t0, input #address of string
lbu $t1, 1($t0) #Get first digit of actual number
li $a1, 10 #Ascii of line feed
li $a0, 0 #accumulator
addi $t1,$t1,-48 #Convert from ASCII to digit
move $a2, $t1 #$a2=$t1 goto checkdigit
jal checkdigit
add $a0, $a0, $t1 #Accumulates
addi $t0, $t0, 1 #Advance string pointer
lbu $t1, ($t0) #Get next digit
buc1:
beq $t1, $a1, print #if $t1=10(linefeed) then print
addi $t1,$t1,-48 #Convert from ASCII to digit
move $a2, $t1 #$a2=$t1 goto checkdigit
jal checkdigit
mul $t2, $a0, 10 #Multiply by 10
add $a0, $t2, $t1 #Accumulates
addi $t0, $t0, 1 #Advance string pointer
lbu $t1, ($t0) #Get next digit
b buc1
print:
add $a0, $a0, 5
li $v0, 1
syscall
b end
checkdigit:
blt $a2, $t3, error
bgt $a2, $t4, error
jr $ra
error:
la $a0, msgerror
li $v0, 4 #print eror
syscall
end:
li $v0, 10 #end program
syscall
However, my code ends up producing:
Enter a string:
x123
The value +5 is:
1128
(128 is the expected).
How can I make one of the duplicate numbers go away? I've tried incrementing the address by 1 with print statements, but it seems not to work with anything else/not as intended.
li $v0,4
la $a0, aString
add $a0, $a0, 1
syscall
The above snippet produces 23 if 123 is entered, but I can't get it to apply to the above.
Easier overall approaches are welcome too. New to mips, so I hardly think mine is all that great.
Looks like you read the first digit twice.
This part:
li $t3,0
li $t4,9
la $t0, input #address of string
lbu $t1, 1($t0) #Get first digit of actual number
Should be changed to:
li $t3,0
li $t4,9
la $t0, input+1 #address of first digit in string
lbu $t1, ($t0) #Get first digit of actual number
Related
This is my first time coding PCSPIM. I find that there is a little trouble with my code.
.data
user_input: .asciiz "\n\nEnter an Integer for the value of n: "
result_display: .asciiz "\nThe sum from 0 to n is "
Greeting: .asciiz "\n\nThank you!"
.text
main:
#user input
li $v0, 4
la $a0, user_input
syscall
#allow user input
li $v0, 5
syscall
#store the input value into t8
move $t8, $v0
#calculation
addi $s0, $zero, $t8
I wish to use the integer value ($t8) that users input into the #calculation section, but it ends up with error.
addi $t0, $zero, 0
loop1:
add $t0, $t0, $s0
addi $s0, $s0, -1
bne $s0, $zero, loop1
nop
nop
# Display the result
li $v0, 4
la $a0, result_display
syscall
# Print out the result
li $v0, 1
move $a0, $t0
syscall
# Greets the user
li $v0, 4
la $a0, Greeting
syscall
# Exit the program
li $v0, 10
syscall
Sorry for my broken English.
The error is in the way you are using the "addi" instruction. The instruction requires an immediate (number) value to be passed as the third operand and not an architectural register. If you update the "addi" instruction to "addu" the code should work.
sorry, I try to multiply two integers but it doesn't work. I can't find where the problem is.Maybe because of register' names but I don't know how to correct it. I correct many times but it is not successful. Could anyone give me some points?
.data
prompt1: .asciiz "Please enter the first signed (decimal) integer: "
prompt2: .asciiz "Please enter the second signed (decimal) integer: "
result_msg: .asciiz "The result of these two 16-bit integers\' multiplication is: "
.text
.globl main
main:
li $v0, 4 #print prompt
la $a0, prompt1
syscall
li $v0, 5 #read multiplicand
syscall
move $s0, $v0
li $v0, 4 #print prompt
la $a0, prompt2
syscall
li $v0, 5 #read multiplier
syscall
move $s1, $v0
Mult: ori $t0,$zero,1 #mask
move $s3, $0 #initialize the result register
move $t1, $0
loop: beq $s1, $zero, end #if the multiplier is 0 then finished
and $t1, $t0, $s1 #mask
beq $t1, 1, mult_add
beq $t1, 0, shift
mult_add: addu $s3, $s3, $s0 #add to get product
shift:
sll $s0, $s0, 1 #shift multiplicand left
srl $s1, $s1, 1 #shift multiplier right
j loop
end:
jr $ra
result: #input the print_string
li $v0, 4
la $a0, result_msg
syscall
exit:
li $v0, 1 #input result
move $a0, $s3
syscall
li $v0, 10 #exit
syscall
Inspecting your code I see that you jump to label end when you are done multiplying.
The instruction at that label issues a jr $ra which "returns from a function", but I guess you just want to print the result and exit.
Therefore I'd suggest you remove that instruction so as to print the result and exit and maybe remove label result as it is not used anywhere in your code.
I'm trying to practice my coding skill in MIPS (this is my first time ever learning an assembly language). I wrote this code below to sum up two user's inputs, and it is correct. However, the code is quite long..so, is there any way to optimize this code so it will be shorter? i need some suggestions. Thanks
.data
n1: .asciiz "enter your first number: "
n2: .asciiz "enter your second number: "
result: .asciiz "result is "
.text
#getting first input.
la $a0, n1
li $v0, 4
syscall
li $v0, 5
syscall
move $t0, $v0
#getting second input.
la $a0, n2
li $v0, 4
syscall
li $v0, 5
syscall
move $t1, $v0
#calculate and print out the result.
la $a0, result
li $v0, 4
syscall
add $t3, $t0, $t1
move $a0, $t3
li $v0, 1
syscall
#end program.
li $v0, 10
syscall
I also have wrote a program to calculate a factorial number. There are better ways to do this?
.data
str: .asciiz "Enter a number: "
result: .asciiz "The result is: "
.text
la $a0, str
li $v0, 4
syscall
li $v0, 5
syscall
move $s0, $v0 # move N into s0
li $s2, 1 # c = 1
li $s1, 1 # fact = 1
LOOP:
blt $s0, $s2, PRINT # if (n < c ) print the result
mul $s1, $s1, $s2 # fact = fact * c
add $s2, $s2, 1 # c = c + 1
j LOOP
PRINT:
la $a0, result
li $v0, 4
syscall
add $a0, $s1, $zero
li $v0, 1
syscall
li $v0, 10
syscall
The programs look ok, except for the use of the temporary registers $t0,...,$t9. These registers are not guaranteed to be preserved when another function is called, or when a syscall is issued. The $s0,...,$s7 registers are preserved across calls.
You need to replace: move $t0, $v0 with move $s0, $v0; move $t1, $v0 with move $s1, $v0 and add $t3, $t0, $t1 with add $s3, $s0, $s1.
What does the following QtSPIM/MIPS code do. Describe by referring to the functions of various blocks of the code (Block1, Block2, …).
Answer the questions in front of certain instructions.
Block1:
.text
main:
li $s4, 0
la $a0, input
li $v0, 4
syscall
li $v0, 5
syscall
move $t0, $v0 #Why do we need this?
Block2:
la $a0, output
li $v0, 4
syscall
move $a0, $t0
li $v0, 1
syscall
la $a0, newline # How will the output change if newline is replaced by newspace defined as “ “?
li $v0, 4
syscall
Block3:
Do:
move $a0, $s4
li $v0, 1
syscall
la $a0, newline
li $v0, 4
syscall
slt $s1, $s4, $t0
addi $s4, $s4, 1
bgt $s1, $zero, Do # Why can’t we use “beq $s1, 1, Do “?
Block4:
Exit:
li $v0, 10
syscall
.data
input: .asciiz "Input a number: "
output: .asciiz "Let me count till "
newline: .asciiz "\n "
So I need help with identifying what the code does... I have the concept I just want o make sure Im properly figuring this out... So I have this so far:
move $t0, $v0 #Why do we need this? --- to store number in t0
la $a0, newline # How will the output change if newline is replaced by newspace defined as “ “?
--- load address of string to be printed into $a0 and adds the space if replaced by newspace
the last one I cant quite figure out...
I trying to write a MIPS program that gets an unsigned integer as argument and returns the sum of all decimal digits in the integer recursively. For example if the argument is 75080 then the sum to be returned is 20 (7+5+0+8+0). Here is my code so far. Any help would be appreciated.
My way of thinking was to divide the number by 10 leaving me with the last integer in the number, add the reminder using mfhi.
.data
prompt: .asciiz "Enter a string of integer: "
output: .asciiz "\nThe total sum is: "
.text
.globl main
main:
la $a0, prompt
li $v0, 4
syscall
li $v0, 5
syscall
move $t2, $v0
la $a0, output
li $v0, 4
syscall
Loop:
div $t2, $t2, 10
mflo, $t1
mfhi, $t3
beqz $t1, Exit
add $t1, $t1, 0
b additive
additive:
add $t0, $t1, $t1
j Loop
Exit:
la $a0, output
li $v0, 4
syscall
la $v0, 10
syscall
What's this supposed to be doing? Adding 0 to the register won't change its value:
add $t1, $t1, 0
After dividing and copying to $t1 and $t3, the quotient is in $t1 and the remainder is in $t3. You're treating it the other way around when you add to the total.
This is actually going to give you $t0 = 2 * $t1: you're adding $t1 to itself and storing the result in $t0.
add $t0, $t1, $t1
You probably actually want:
add $t0, $t0, $t3
You're checking for $t1 == 0 before adding the remainder to the total, so the most significant digit will never get added. You don't really need a subroutine for adding to the total either. You can also use bnez Loop instead of beqz Exit -> b Loop. Lastly, you don't even need $t1, because the quotient is already in $t2.
Get rid of additive and replace Loop with this:
Loop:
div $t2, $t2, 10
mfhi, $t3
add $t0, $t0, $t3
bnez $t2, Loop
Your Exit is weird: you're printing the output string a second time instead of printing the integer.
Change it to this:
Exit:
move $a0, $t0
la $v0, 1
syscall
la $v0, 10
syscall
The approach is quite simple. You need recursive function, I named it SumDigits that will take the last digit and repeat procedure for all digits in the argument. After the recursive call returns you'll add digit to the previous result. The code is commented for easier understanding. The code follows:
.text
#calculates sum of digits recursively
SumDigits:
sub $sp, $sp, 12 #alloocate 12B on stack
sw $ra 0($sp) #save return address
sw $a0, 4($sp) #save argument
beq $a0, $0, exit_sumdigits #when there is no more digits return 0
rem $t0, $a0, 10 #get last digit
sw $t0, 8($sp) #save it on stack
div $a0, $a0, 10 #divide argument by 10
jal SumDigits #repeat procedure
lw $t0, 8($sp) #read digit from stack
add $v0, $v0, $t0 #add digit to previous result
lw $ra, 0($sp) #load return address
addi $sp, $sp, 12 #free stack
jr $ra #return
exit_sumdigits:
li $v0, 0 #there are no more digits, return 0
lw $ra, 0($sp) #load return address
addi $sp, $sp, 12 #free stack
jr $ra #return
main:
li $a0, 75080 #load number in $a0
jal SumDigits #call SumDigits
move $a0, $v0 #set a0 = result of SumDigits
li $v0, 1 #set $v0 for print int system call
syscall
li $v0, 10 #set $v0 for exit system call
syscall
.data