MIPS MARS ASSEMBLY CODE operand is of incorrect type - mips

.data
prompt: .asciiz "Please enter an integer: "
x: .double 2.0
tolerance: .double 1e-6
.text
main:
# Prompt user for initial value of x
li $v0, 4
la $a0, prompt
syscall
# Read in user input
li $v0, 7
syscall
# Convert user input to double and store in x
mtc1 $v0, $f12
cvt.d.w $f0, $f12
sdc1 $f0, x
# Initialize counter and F(x) value
li $t0, 0
ldc1 $f12, x
add.d $f14, $f12, $f12
mul.d $f14, $f12, $f14
add.d $f14, $f14, 1
# Loop until F(x) is within tolerance
loop:
# Calculate x{n+1}
ldc1 $f12, x
add.d $f13, $f12, $f12
mul.d $f13, $f12, $f13
mul.d $f13, $f13, $f12
add.d $f13, $f13, -8
mul.d $f13, $f13, $f12
div.d $f12, $f14, $f13
# Calculate F(x)
ldc1 $f12, x
add.d $f14, $f12, $f12
mul.d $f14, $f12, $f14
add.d $f14, $f14, 1
# Print current x and F(x) values
li $v0, 3
ldc1 $f12, x
syscall
li $v0, 11
li $a0, ','
syscall
li $v0, 3
ldc1 $f14, $f14
syscall
li $v0, 11
li $a0, '\n'
syscall
# Check if F(x) is within tolerance
ldc1 $f12, x
ldc1 $f14, tolerance
c.lt.d $f12, $f14
beq $0, $0, done
# Increment counter and repeat loop
addi $t0, $t0, 1
b loop
done:
# Print root found
li $v0, 4
la $a0, "Root found: "
syscall
li $v0, 3
ldc1 $f12, x
syscall
# End program
li $v0, 10
syscall
line 29 column 19: "1": operand is of incorrect type
line 46 column 23: "1": operand is of incorrect type
line 56 column 5: "ldc1": Too few or incorrectly formatted operands. Expected: ldc$f2,-100($t2)
line 75 column 5: "la": Too few or incorrectly formatted operands. Expected: la $t1,($t2)
Does anyone know what I'm doing wrong here? My goal is to write a MIPS program which will find a value of xn such that F(xn)=0, to a tolerance of 10-6 with the given formula ๐‘ฅ๐‘›+1 = ๐‘ฅ๐‘› โˆ’ (๐น(๐‘ฅ๐‘›)/๐นโ€ฒ(๐‘ฅ๐‘›)).
For example consider a continuous function F(x)=x3-4x2+1 with its derivative Fโ€™(x)=3x2-8x. Thus, by calculating successive values of x, the value of F(xn) will approach 0, and hence be a root of F.
I am fairly new to MIPS and I'm having trouble.

Related

Getting Memory out of bounds exception while running code in QTSPIM

I am trying an array to save i * j values and print the values from array.
I have two loops loop1, loop2, where loop1 takes i and loop2 takes on j.
I am trying to save the i * j in a myarray which is space datatype.
I am getting exception Memory address out of bounds and unable to find whats the error.
.data
myarray: .space 10000
n: .word 1
space_line: .asciiz " "
new_line: .asciiz "\n"
.text
.globl main
main:
lw $a0, n
la $a1, myarray
li $a2, -1 #row
li $t0, 0
li $t2, 0
loop1:
addi $a2, $a2,1
bge $a2, $a0, print_loop
li $a3, 0 #column
j loop2
loop2:
bge $a3, $a0, loop1
#multiply a2 and a3
mul $t1, $a2, $a3
sw $t1, 0($a1)
addu $a1, $a1,4
addi $a3, $a3,1
j loop2
print_loop:
mul $t3, $a0, $a0
bge $t0, $t3, exit
li $v0, 4
lw $a0, myarray($t2)
syscall
li $v0, 4
lw $a0, space_line
syscall
rem $t4, $t3, $a0
beqz $t4, newline
addu $t2, $t2, 4
addi $t0, $t0, 1
j print_loop
newline:
li $v0, 4
lw $a0, myarray($t2)
syscall
exit:
# Done, terminate program.
li $v0, 10
syscall # all done!
.end main
For n =4,i am expecting the output in console as
0 0 0 0
0 1 2 3
0 2 4 6
0 4 8 12
You can find this problem by single stepping in the debugger.ย  Start with the smallest possible input, like n=1 as you're showing.ย  After each instruction, verify that it did what you want, and that it didn't do anything else except what you wanted.
Here's a hint: Pay attention to the difference between la and lw.ย  Also, If you want to put syscalls in the middle of your code or loops, then avoid the $a0 and $v0 registers for your own variables โ€” just makes things easier/better.

Why is MIPS printing memory locations on the second time around

[Solved]
We were tasked with writing a bubble sort in MIPS and printing both the unsorted and sorted arrays
I've written the following code to accomplish this.
But when I go to run it, the original array prints as I would expect
Original Array
[34, 23, -1, -2, 0]
But then it prints this for the sorted array.
Sorted Array
[173496791, 1818324585, 1920090400, 686433, 1919898378]
(the Unicode squares do print)
array: .word 34, 23, -1, -2, 0, 89
length: .word 6
original: .asciiz "Original Array\n"
sorted: .asciiz "\nSorted Array\n"
.text
# main()
main:
la $a2, length
lw $a2, 0($a2) # a2 <= n_element
add $t9, $0, $0 # t9 : counter
la $a1, array # a1 = &array[0]
addi $t0, $0, 0 # for t0=0 to
addi $a2, $a2, -1 # because we do [i+1]
#says prints original array
la $a0, original
li $v0, 4
syscall
#prints array
jal print
#printing the string saying sorted
la $a0, sorted
li $v0, 4
syscall
#after printing original we reset the values?
la $a2, length
lw $a2, 0($a2) # a2 <= n_element
add $t9, $0, $0 # t9 : counter
add $t8, $0, $0 # t10 : counter 2
la $a1, array # a1 = &array[0]
addi $t0, $0, 0 # for t0=0 to
addi $a2, $a2, -1 # because we do [i+1]
#see if that worked it did
li $s0, 1 #boolean swapped = false 0=false 1=true
outerLoop:
beqz $s0, exit #if flag is false exit
li $s0, 0
addi $a1, $a1, 4 # next array offset
addi $t9, $t9, 1 # counter++
move $t8 $0
sub $s2, $a2, $t9
innerLoop:
bge $t8, $s2, exitInner
lw $t7, 0($a1) # t7 = array[i]
lw $t8, 4($a1) # t8 = array[i+1]
ble $t7, $t8, skip #if array[i]<= arr[i+1] skip the swapping
sw $t8, 0($a1) #a[i+1] = a[1]
sw $t7, 4($a1) #a[i] = a[i+1]
li $s0, 1#flag update
skip:
addi $t8, $t8, 1 #count
addi $a1, $a1, 4
j innerLoop
exitInner:
j outerLoop
exit:
la $a2, length
lw $a2, 0($a2) # a2 <= n_element
add $t9, $0, $0 # t9 : counter
addi $a2, $a2, -1 # because we do [i+1]
jal print
j quit#end Program
#print array
print:
lw $t7,0($a1) # t7 = array[i]
lw $t8,4($a1) # t8 = array[i+1]
add $a0, $t7, 0
addi $v0, $0, 1 #print int using system call the value stored in a0
syscall
addi $a0, $0, 0x20 # ascii 0x20 = ' '
addi $v0, $0, 11
syscall
addi $a1, $a1, 4 # next array offset
addi $t9, $t9, 1 # counter++
beq $t9, $a2, return #return to the where we were we were at beforehand
j print
return:
jr $ra
quit:
addi $v0, $0, 10
syscall
I think these are memory locations? I'm not sure why it's printing that as it is because I reset my counter values before trying to print. So the question is. Why am I printing memory locations? if that is what is happening
I was sorting in place so I had to reset the array before the print function.

MIPS Programs with more than 4 arguments

The following is my code and the final test case. main and printStats are both given, I had to qrite average (which is at the bottom), so look there for problems. This case changes the value of all registers in $f, $t, $a, and $s and adds 2 items to the top of its stack in order to ensure that the average method is preserving properly the values it will need to run its calculations following the $jr from printStats.
The problem I am having is recurring in a few test cases where there are 3 batters. Batter 3 uses arbitrarily large integers.
# printStats puts two values at the top two spots in its stack. This is where
# the number of homeruns and outs were placed when printStats
# is called. A function is allowed to change its own stack.
# Changes the $s registers used by main. The average function should be
# getting arguments from the $a registers and the stack, and not relying
# on what is in the $s registers.
# From test12:
# Tests if $t registers are preserved (if needed) by average.
# printStats puts values into every $t register.
# From test13:
# Tests if $a registers used correctly when average calls printStats.
# printStats changes the contents of $a1, $a2, and $a3 before returning
# test with three batters, both average and slugging percentage
# First batter has no hits, but does have outs
# Second batter has hits and outs, with realistic values
# Third hitter has large values for some of the hits and for the
# outs. This means the hits and outs *have* to be converted from int's
# to float's in order to get the right answer.
.data
mainNumBatters:
.word 3
mainBatter1:
.word 27 # walks
.word 0 # singles
.word 0 # doubles
.word 0 # triples
.word 0 # home runs
.word 423 # outs
mainBatter2:
.word 27 # walks
.word 101 # singles
.word 22 # doubles
.word 4 # triples
.word 10 # home runs
.word 423 # outs
mainBatter3:
.word 102322 # walks
.word 8000000 # singles
.word 22 # doubles
.word 500000 # triples
.word 10 # home runs
.word 23000000 # outs
.data
mainNewline:
.asciiz "\n"
mainBatterNumber:
.asciiz "Batter number: "
mainBattingAverage:
.asciiz "Batting average: "
mainSluggingPercentage:
.asciiz "Slugging percentage: "
mainOnbasePercentage:
.asciiz "On-base percentage: "
.text
main:
# Function prologue -- even main has one
addiu $sp, $sp, -24 # allocate stack space -- default of 24 here
sw $fp, 0($sp) # save frame pointer of caller
sw $ra, 4($sp) # save return address
addiu $fp, $sp, 20 # setup frame pointer of main
# for (i = 0; i < mainNumBatters; i++)
# compute batting average
# compute slugging average
la $s1, mainNumBatters
lw $s6, 0($s1) # $s6 = number of batters
addi $s0, $zero, 0 # $s0 = i = 0
la $s1, mainBatter1 # $s1 = addr of current batter's stats
mainLoopBegin:
slt $t0, $s0, $s6 # $t0 = i < number of batters
beq $t0, $zero, mainDone
la $a0, mainBatterNumber
addi $v0, $zero, 4
syscall
addi $a0, $s0, 1
addi $v0, $zero, 1
syscall
la $a0, mainNewline
addi $v0, $zero, 4
syscall
# Compute the batting average
addi $a0, $zero, 1 # $a0 = 1 = compute batting average
lw $a1, 0($s1) # $a1 = walks
lw $a2, 4($s1) # $a2 = singles
lw $a3, 8($s1) # $a3 = doubles
lw $s2, 12($s1) # $s2 = triples
lw $s3, 16($s1) # $s3 = home runs
lw $s4, 20($s1) # $s4 = outs
sw $s4, -4($sp) # put outs at top of average's stack
sw $s3, -8($sp) # put homeruns 2nd fm top of average's stack
sw $s2, -12($sp) # put triples 3rd fm top of average's stack
jal average
# Print the batting average
mtc1 $v0, $f12 # get result fm $v0 before we print string
la $a0, mainBattingAverage
addi $v0, $zero, 4
syscall
addi $v0, $zero, 2 # print the average
syscall
la $a0, mainNewline
addi $v0, $zero, 4
syscall
syscall
# do it for the slugging percentage
addi $a0, $zero, 2 # $a0 = 2 = compute slugging average
lw $a1, 0($s1) # $a1 = walks
lw $a2, 4($s1) # $a2 = singles
lw $a3, 8($s1) # $a3 = doubles
lw $s2, 12($s1) # $s2 = triples
lw $s3, 16($s1) # $s3 = home runs
lw $s4, 20($s1) # $s4 = outs
sw $s4, -4($sp) # put outs at top of average's stack
sw $s3, -8($sp) # put homeruns 2nd fm top of average's stack
sw $s2, -12($sp) # put triples 3rd fm top of average's stack
jal average
# Print the slugging percentage
mtc1 $v0, $f12 # get result fm $v0 before we print string
la $a0, mainSluggingPercentage
addi $v0, $zero, 4
syscall
addi $v0, $zero, 2 # print the percentage
syscall
la $a0, mainNewline
addi $v0, $zero, 4
syscall
syscall
# do it again for the on-base percentage
addi $a0, $zero, 3 # $a0 = 3 = compute slugging average
lw $a1, 0($s1) # $a1 = walks
lw $a2, 4($s1) # $a2 = singles
lw $a3, 8($s1) # $a3 = doubles
lw $s2, 12($s1) # $s2 = triples
lw $s3, 16($s1) # $s3 = home runs
lw $s4, 20($s1) # $s4 = outs
sw $s4, -4($sp) # put outs at top of average's stack
sw $s3, -8($sp) # put homeruns 2nd fm top of average's stack
sw $s2, -12($sp) # put triples 3rd fm top of average's stack
jal average
# Print the slugging percentage
mtc1 $v0, $f12 # get result fm $v0 before we print string
la $a0, mainOnbasePercentage
addi $v0, $zero, 4
syscall
addi $v0, $zero, 2 # print the percentage
syscall
la $a0, mainNewline
addi $v0, $zero, 4
syscall
syscall
addi $s0, $s0, 1 # i++
addi $s1, $s1, 24 # $s1 = addr of next batter's stats
j mainLoopBegin
mainDone:
# Epilogue for main -- restore stack & frame pointers and return
lw $ra, 4($sp) # get return address from stack
lw $fp, 0($sp) # restore frame pointer for caller
addiu $sp, $sp, 24 # restore frame pointer for caller
jr $ra # return to caller
.data
printStatsOuts:
.asciiz "Outs: "
printStatsWalks:
.asciiz "Walks: "
printStatsSingles:
.asciiz "Singles: "
printStatsDoubles:
.asciiz "Doubles: "
printStatsTriples:
.asciiz "Triples: "
printStatsHomeruns:
.asciiz "Home runs: "
printStatsNewline:
.asciiz "\n"
.text
printStats:
# Function prologue
addiu $sp, $sp, -32 # allocate stack space
sw $a3, 20($sp) # save $a0 thru $a3
sw $a2, 16($sp)
sw $a1, 12($sp)
sw $a0, 8($sp)
sw $ra, 4($sp) # save return address
sw $fp, 0($sp) # save frame pointer of caller
addiu $fp, $sp, 28 # setup frame pointer of average
# printStats expects to find the following:
# $a0 = walks
# $a1 = singles
# $a2 = doubles
# $a3 = triples
# 5th argument = homeruns
# 6th argument = outs
# print the outs
la $a0, printStatsOuts
syscall
lw $a0, 0($fp) # the outs are at the top of our stack
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# print the walks
la $a0, printStatsWalks
addi $v0, $zero, 4
syscall
lw $a0, 8($sp) # the walks were passed in $a0
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# print the singles
la $a0, printStatsSingles
addi $v0, $zero, 4
syscall
addi $a0, $a1, 0 # the singles were passed in $a1
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# print the doubles
la $a0, printStatsDoubles
addi $v0, $zero, 4
syscall
addi $a0, $a2, 0 # the doubles were passed in $a2
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# print the triples
la $a0, printStatsTriples
addi $v0, $zero, 4
syscall
addi $a0, $a3, 0 # the doubles were passed in $a3
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# print the homeruns
la $a0, printStatsHomeruns
addi $v0, $zero, 4
syscall
lw $a0, -4($fp) # the homeruns are 4 bytes below the top of our stack
addi $v0, $zero, 1
syscall
la $a0, printStatsNewline
addi $v0, $zero, 4
syscall
# Put -1 in $t0, then copy that value to each of the $f registers
addi $t0, $zero, -1
mtc1 $t0, $f0
mtc1 $t0, $f1
mtc1 $t0, $f2
mtc1 $t0, $f3
mtc1 $t0, $f4
mtc1 $t0, $f5
mtc1 $t0, $f6
mtc1 $t0, $f7
mtc1 $t0, $f8
mtc1 $t0, $f9
mtc1 $t0, $f10
mtc1 $t0, $f11
mtc1 $t0, $f12
mtc1 $t0, $f13
mtc1 $t0, $f14
mtc1 $t0, $f15
mtc1 $t0, $f16
mtc1 $t0, $f17
mtc1 $t0, $f18
mtc1 $t0, $f19
mtc1 $t0, $f20
mtc1 $t0, $f21
mtc1 $t0, $f22
mtc1 $t0, $f23
mtc1 $t0, $f24
mtc1 $t0, $f25
mtc1 $t0, $f26
mtc1 $t0, $f27
mtc1 $t0, $f28
mtc1 $t0, $f29
mtc1 $t0, $f30
mtc1 $t0, $f31
# Put various values in the $t registers
addi $t0, $zero, -1111
addi $t1, $zero, -2222
addi $t2, $zero, -3333
addi $t3, $zero, -4444
addi $t4, $zero, -5555
addi $t5, $zero, -6666
addi $t6, $zero, -7777
addi $t7, $zero, -8888
addi $t8, $zero, -9999
addi $t9, $zero, -1111
# Put various values in the $a registers.
addi $a0, $zero, -1111
addi $a1, $zero, -1111
addi $a2, $zero, -2222
addi $a3, $zero, -3333
# Put two values at the top two spots in our stack. This is where
# the number of homeruns and outs were placed when printStats
# is called. A function is allowed to change its own stack.
addi $t7, $zero, -1234
sw $t7, 0($fp)
sw $t7, -4($fp)
printStatsDone:
# Epilogue for printStats -- restore stack & frame pointers and return
lw $ra, 4($sp) # get return address from stack
lw $fp, 0($sp) # restore frame pointer for caller
addiu $sp, $sp, 32 # restore frame pointer for caller
jr $ra # return to caller
# Your code goes below this line
average:
#takes 7 arguments
#Arguments $a0-$a3 are put on the Caller's stack
#arguments 5-7 are put on the Callee's stack and called
# Prologue: set up stack and frame pointers for average
addiu $sp, $sp, -36 # allocate stack space -- 36 needed here
sw $fp, 0($sp) # save caller's frame pointer
sw $ra, 4($sp) # save return address
# save parameter values $a0-$a3 on the stack
sw $a0, 8($sp) # designates which calculation to do
sw $a1, 12($sp) # walks
sw $a2, 16($sp) # singles
sw $a3, 20($sp) # doubles
addiu $fp, $sp, 32 # setup average frame pointer
#Allocate proper locations of arguments for printStats
#arguments 5 and 6 (home runs and outs will be placed on stack)
addi $t5, $a0, 0 #$t5 designates which calculation to run
addi $a0, $a1, 0 #walks of printStats
addi $a1, $a2, 0 #singles of printStats
addi $a2, $a3, 0 #doubles of printStats
lw $a3, 24($sp) #triples of printStats
lw $t1, 28($sp) #home runs of printStat
sw $t1, -8($sp) #home runs now 2nd from top of stack
lw $t2, 32($sp) #outs of printStats
sw $t2, -4($sp) #out now top of stack
jal printStats
#restore registers used in average
lw $t2, 32($sp) #outs
lw $t1, 28($sp) #homeruns
lw $a3, 24($sp) #triples
lw $a2, 20($sp) #doubles
lw $a1, 16($sp) #singles
lw $a0, 12($sp) #walks
lw $t5, 8($sp) #compare which calculation to run
#convert outs to float
mtc1 $t2, $f4 #outs = $f4
#hits
#hits = singles + doubles + triples + home runs
add $t3, $a1, $a2 # hits = singles + doubles
add $t3, $t3, $a3 # hits = $t3 + triples
add $t3, $t3, $t1 # hits = $t3 + home runs
mtc1 $t3, $f1 #convert hits to float $f1
#atBats
#atBats = hits + outs
add.s $f2, $f1, $f4 # atBats = hits + outs
mfc1 $t4, $f2 #convert atBats to int for compare
#Compare $t5
#if $t5 == 1, computer batting average
#if $t5 == 2, compute slugging percentage
#if $t5 == 3, compute on-base percentage
addi $t0, $zero, 1 #$t0 = 1
beq $t5, $t0, averageBattingAverage
addi $t0, $zero, 2 #$t0 = 2
beq $t5, $t0, averageSluggingPercentage
addi $t0, $zero, 3 #$t0 = 3
beq $t5, $t0, averageOnBasePercentage
averageBattingAverage:
#batting average
#batting average = hits/atBats
#if atBats == 0, average = 0
#compare atBats
beq $t4, $zero, averageBattingSluggingZero
#batting
div.s $f3, $f1, $f2 #batting average = hits/atBats
#Set to print
mfc1 $v0, $f3 #return $v0 the batting average
j averageDone #done
averageSluggingPercentage:
#Slugging percentage
#slugging percentage = (singles + doubles*2 + triples*3
# + home runs*4)/atBats
#if atBats == 0, percentage = 0
#compare atBats
beq $t4, $zero, averageBattingSluggingZero
#slugging
add $t5, $a2, $a2 #doubles*2
add $t6, $a3, $a3 #$t6 = triples * 2
add $t6, $t6, $a3 #$t6 = triples * 3
add $t7, $t1, $t1 #$t7 = home runs * 2
add $t7, $t7, $t7 #$t7 = home runs * 4
add $t8, $a1, $t5 #$t8 = singles + doubles*2
add $t8, $t8, $t6 #$t8 = $t8 + triples*3
add $t8, $t8, $t7 #$t8 = $t8 + home runs*4
mtc1 $t8, $f1 #convert $t8 to float $f1
div.s $f3, $f1, $f2 #slugging percentage = $f1/atBats
#set to print
mfc1 $v0, $f3 #return $v0 the slugging percentage
j averageDone #done
averageOnBasePercentage:
#On-base percentages
#on-base percentages = (hits + walks)/(atBats + walks)
#if atBats + walks is zero, percentage is zero
add $t6, $t3, $a0 #$t6 = hits + walks
add $t7, $t4, $a0 #$t7 = atBats + walks
#compare atBats + walks
beq $t7, $zero, averageOnBaseZero
#on-base
mtc1 $t6, $f1 #convert $t6 to float $f6
mtc1 $t7, $f2 #convert $t7 to float $f7
div.s $f3, $f1, $f2 #on-base percentage = $f6/$f7
#set to print
mfc1 $v0, $f3 #return $v0 the on-base percentage
j averageDone #done
averageBattingSluggingZero:
#if atBats is zero, batting average and slugging
#percentage are both zero
addi $t0, $zero, 0 #$t0 = 0
mtc1 $t0, $f0 #convert 0 to float $f0
#set to print
mfc1 $v0, $f0 #return $v0 = 0
j averageDone #done
averageOnBaseZero:
#if atBats + walks is zero, on-base percentage
# is also zero
addi $t0, $zero, 0 #$t0 = 0
mtc1 $t0, $f0 #convert 0 to float $f0
#set to print
mfc1 $v0, $f0 #return $v0 = 0
j averageDone #done
averageDone: # Epilogue: restore stack and frame pointers and return
lw $ra, 4($sp) # get return address from stack
lw $fp, 0($sp) # restore the caller's frame pointer
addiu $sp, $sp, 36 # restore the caller's stack pointer
jr $ra # return to caller's code
My outputs are not lining up and I don't get why.
The following is the correct output for batter 3.
Batter number: 3
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
Batting average: 0.26984200
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
Slugging percentage: 0.30158967
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
On-base percentage: 0.27220613
And here's my output, with a ! to mark the inconsistencies
Batter number: 3
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
!Batting average: 0.22532867
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
!Slugging percentage: 0.25183919
Outs: 23000000
Walks: 102322
Singles: 8000000
Doubles: 22
Triples: 500000
Home runs: 10
!On-base percentage: 0.22559348
How are my calculations off for this one batter, and what can I do to fix it?
There are multiple calling conventions, you should figure out which one you are supposed to follow. If you have no documentation, you could look at compiler-generated assembly code, or use a debugger.
That said, judging from the fact that only 4 arguments are passed on the stack, you seem to be using the O32 calling convention. This means, the stack upon entry to your function contains 4 argument slots for saving the first 4 arguments which are passed in the registers $a0-$a3. Following them are all the remaining arguments. So, upon entry to your function, the 5th argument (the first one that is not passed via register) will be at address 16($sp) with the 6th at 20($sp) and the 7th at 24($sp). (This is assuming your arguments are 1 word each.) You subtract 36 from $sp to make space for your locals, thus after that all the offsets increase by that amount, i.e. 5th argument at 52($sp) and so on. You can access them using these addresses.
You then set $fp to $sp + 32. I don't think calling convention mandates any particular value for $fp, so that should be fine. If you subsequently wish to access your arguments relative to $fp, you need to adjust the offsets again to compensate, this time by -32. Thus, 5th argument should be at 20($fp), followed by the rest.

MIPS branching always the same

So with this MIPS code I'm trying to get a users input of a tree size they would like and the output is the cost. 199 for > 8, 99 >= 6, 69 >= 3, 39 >= 0, and just a phrase saying positive only for a negative input.
My problem is that no matter the input, the program always spits out 69, whats wrong?
#data declarations: declare variable names used in program, storage allocated in RAM
.data
msg1: .asciiz "Enter the height of a tree to purchase: "
msg21: .asciiz "The cost: "
msg22: .asciiz " dollars\n"
msg3: .asciiz "\n"
msgNeg: .asciiz "Please enter a positive integer for the tree height.\n"
big: .word 8
med: .word 6
small: .word 3
negative: .word 0
#The program begins after .text
.text
main:
#Prints first line and receives input
la $a0, msg1
li $v0, 4
syscall
li $v0, 5
syscall
la $a0, msg3
li $v0, 4
syscall
#Stores user input in parameter variable
move $a0, $v0
#Calls cost function to determine cost
addi $sp, $sp, -4
sw $ra, 0($sp)
jal cost
lw $ra, 0($sp)
addi $sp, $sp, 4
#stores returned value to temporary register
move $t0, $v0
#Prints out the cost of the tree
la $a0, msg21
li $v0, 4
syscall
move $a0, $t0
li $v0, 1
syscall
la $a0, msg22
li $v0, 4
syscall
#return
jr $ra
cost:
#finds the range of the user value
la $t6, small
lw $t7, 0($t6)
bge $a0, $t7, smTree
nop
la $t6, med
lw $t7, 0($t6)
bge $a0, $t7, medTree
nop
la $t6, big
lw $t7, 0($t6)
bgt $a0, $t7, bigTree
nop
la $t6, negative
lw $t7, 0($t6)
blt $a0, $t7, negTree
nop
#else statement, returns 39
li $v0, 39
jr $ra
bigTree:
#first branch, returns 199
li $v0, 199
jr $ra
medTree:
#second branch, returns 99
li $v0, 99
jr $ra
smTree:
#third branch, returns 69
li $v0, 69
jr $ra
negTree:
#fourth branch, returns a phrase
la $a0, msgNeg
li $v0, 4
syscall
jr $ra
When you're reading the user's number:
li $v0, 5
syscall
la $a0, msg3
li $v0, 4
syscall
#Stores user input in parameter variable
move $a0, $v0
$v0 will no longer hold the user's value. It has been overwritten with 4, which corresponds to the case that returns a cost of 69. You'll have to copy $v0 to another temporary register right after syscall 5.
Also, the logic of cost is currently like this:
if (value >= 3)
return 69;
if (value >= 6)
return 99;
if (value >= 8)
return 199;
So any value >= 3 will return 69, and the larger cases will never be checked. You can just change the order to fix it:
if (value >= 8)
return 199;
if (value >= 6)
return 99;
if (value >= 3)
return 69;

function in mips that calculates the absolute value [duplicate]

This question already has answers here:
Integer absolute value in MIPS?
(5 answers)
Closed 2 years ago.
hello i have an exercise in mips that must call a function to calculates the absolute value of a number
i have write 2 codes but if you have any other solution write it
.data
message:.asciiz "give number: "
.text
main:
li $v0, 4
la $a0, message
syscall
li $v0, 5
syscall
add $t1, $v0, $zero
jal absolute
add $v0,$t2,$zero
li $v0, 1
syscall
li $v0, 10
syscall
absolute: ori $t2,$t1,0 #copy r1 into r2
slt $t3,$t1, $zero #is value < 0 ?
beq $t3,$zero,gg #if r1 is positive, skip next inst
sub $t2,$zero, $t0 #r2 = 0 - r1
jr $ra
gg:
#t2
and the second code is this
.data
question: .asciiz "give number"
.text
main:
li $v0, 4
la $a0, question
syscall
li $v0, 5
syscall
jal absolute
li $v0, 1
syscall
li $v1, 1
syscall
li $v0, 10
syscall
absolute:
slti $t0,$a0,0
bne $t0,$zero,g1
add $v0,$a0,$zero
jr $ra
g1:
sub $t2,$a0,$a0
sub $v1,$t2,$a0
j absolute
Try this:
.data
message: .asciiz "Enter the number: "
.text
.globl main
main:
# print message
li $v0, 4
la $a0, message
syscall
# read integer
li $v0, 5
syscall
slt $t0, $v0, $0 # $t0 = ( $v0 < 0 ? 1 : 0 )
bne $t0, $0, NEGATIVE # if($t0 != 0) goto NEGATIVE
j POSITIVE # goto POSITIVE (and dose nothing)
NEGATIVE:
# ~$v0 + 1
nor $v0, $v0, $0 # NOR with zero = NOT
addi $v0, $v0, 1 # $v0 =+ 1
POSITIVE:
# print $v0
move $a0, $v0
li $v0, 1
syscall
# print new line '\n'
li $v0, 11
addi $a0, $0, 10
syscall
jr $ra
Test:
Enter the number: 10
10
Enter the number: -5
5