Can someone tell me the problem in this one?
`#initializing indexes i,j,k
addi $s0, $zero, 0
addi $s1, $zero, 0
addi $s2, $zero, 0
addi $sp, $sp, -16
sw $s0, 0($sp)
sw $s1, 4($sp)
sw $s2, 8($sp)
while1:
bgt $s0,2,exit1
while2:
sw $ra, 12($sp)
bgt $s1,2,exit2
addi $s1,$s1,1
while3:
sw $ra, 12($sp)
bgt $s2,2,exit3
mul $t0,$s0,$s0
add $t1,$t0,$s1
sll $t2,$t1,3
add $t3,$t2,$a0
add $t4,$t2,$a1
add $t5,$t2,$a2
ldc1 $f4, ($t3)
ldc1 $f6, ($t4)
ldc1 $f8, ($t5)
mul.d $f8,$f6,$f4
sdc1 $f8, ($t5)
addi $s2,$s2,1
j while3
addi $s1,$s1,1
j while2
addi $s0,$s0,1
j while1
exit1:
lw $s0, 0($sp)
addi $sp, $sp, 16
jr $ra
exit2:
lw $s1, 4($sp)
jr $ra
exit3:
lw $s1, 8($sp)
jr $ra
addi $t2,$zero,0
while:
beq $t2,24,exit
ldc1 $f2, 0($a2)
li $v0, 3
add.d $f12,$f2,$f0
syscall
addi $t2,$t2,8
li $v0, 10
syscall
It tells me Exception occurred at PC=0x000000 , Bad address in text read: 0x0000000 and attempt to execute a non-instruction at 0x80000180..
What i want to do is to multiply matrixes A and B and store the result in a third matrix C. The matrixes A,B and C are in the addresses $a0, $a1 and $a2
Related
I am trying to write the fibonacci function in a loop in assembly language, but I cannot find the values I find in a certain order and add them to my stack.
The user will ask for the stack sequence range from us and the loop should be in the form of the equation For n> 1 F (n) = F (n-1) + F (n-2).
I could not understand what is my fault.
Example program should be like that; Enter the sequence number: 6, F(6) = 8
.data
str: .asciiz "Enter the sequence number: \n"
f: .word 0,1
.text
main:
la $s0 f #address of f
lw $s1 0($s0)
addi $a0 $zero 0 #int a0 = f[0]:0(s1)
lw $s2 4($s0)
addi $a1 $zero 1 #int a1 = f[1]:1(s2)
li $v0 4
la $a0 str #print string
syscall
li $v0 5
syscall
move $t0 $v0 #read integer t0=n
jal FIBO
addi $t1 $v0 0 #t1=v0=sum
add $t2 $a0 $a1 #t2=a0+a1=f[0]+f[1];
add $t3 $t2 $t1 #t3=t1+t2
li $v0 1 #print(t3)
addi $a0 $t3 0
li $v0 10 #exit program
syscall
FIBO:
addi $t1 $zero 1 #constant 1
addi $t2 $t0 0 #i:t2=n:t0
addi $t3 $zero 0 #f(i)=0:sum:t3;
#f(n)
#for (i=n, i>1, i--)
# f(i):sum = f(i-1)+f(i-2);
#return f(i)
FIBOLOOP:
slt $t4 $t1 $t2 #t1:1<t2:i
beq $t4 $zero EXIT_LOOP
addi $t4 $t2 -1
addi $t5 $t2 -2
add $t3 $t4 $t5
sub $sp $sp -24
sw $t3 0($sp) #BACKUP-STORING t3----1
sw $t3 4($sp)
sw $t3 8($sp)
sw $t3 12($sp)
sw $t3 16($sp)
sw $t3 20($sp)
subi $t2 $t2 1 # i--: we could write "addi t2 t2 -1" too
j FIBOLOOP
EXIT_LOOP:
add $sp $sp 24 #RESTORE t3---------2
lw $t3 0($sp)
lw $t3 4($sp)
lw $t3 8($sp)
lw $t3 12($sp)
lw $t3 16($sp)
lw $t3 20($sp)
addi $t4 $t3 0
move $v0 $t4
jr $ra
I was hoping that I could get some help debugging some code. I am going to try to not make this a It is for a MIPS assembly project in recursion. The program is only supposed to print prime numbers.
The idea is I have two arrays, one that lists every whole number up to 110, and the other as a flag array that is initialized to all ones.
For every position in the flag array that is a 1 it prints the number and every 0 it doesn't print the number. The good news is I figured out issues with all my loops, the issue I am having is saving the value 0 to the flag array at the position it currently is. Everything that I reference talks about using:
sw [register], ([register])
From what I understand that is how you save the contents of one register to the position of the other? It doesn't seem to work for me. I went ahead and posted the code down bellow, It is kind of messy and really long, but my code for recursion is down where it says Eratosthenes.
.data
NUM_ARRAY: .space 800 # 800-byte memory space
FLAG_ARRAY: .space 800 # 800-byte memory space
START_MSG: .asciiz "The prime numbers up to 110 are:\n"
END_MSG: .asciiz "Completed ...."
SPACE: .asciiz " "
NEWLINE: .asciiz "\n"
BUG1: .asciiz "Out of loop"
INK: .asciiz "incrementK"
INX: .asciiz "incrementX"
.text
.globl main
# THE BEGINNING OF MODULE MAIN #######################
main:
# save the ten registers --------------------------
subu $sp, $sp, 48 # stack frame for 12 registers
sw $ra, ($sp)
sw $s0, 4($sp)
sw $s1, 8($sp)
sw $s2, 12($sp)
sw $s4, 16($sp)
sw $s5, 20($sp)
sw $t0, 24($sp)
sw $t1, 28($sp)
sw $t2, 32($sp)
sw $v0, 36($sp)
sw $a0, 40($sp)
# initialize the essential parameters -------------
li $s0, 111 # the largest number (always - 1)
li $s1, 10 # the square-root of $s0 register
li $s2, 2 # the initial value for "k"
li $s4, 0 # the first numbers to consider
li $s5, 1 # '1' - it is a prime number
li $t2, 0 # loop ounter
# show an opening message ---------------------------------
li $v0, 4 # system call #4
la $a0, START_MSG
syscall
# initialize the two arrays -------------------------------
la $t0, NUM_ARRAY # set the address of the 1st array
la $t1, FLAG_ARRAY # set the address of the 2nd array
loop1: sw $s4, ($t0) # load a number
sw $s5, ($t1) # load the initial property (1 - a prime)
addi $t2, $t2, 1 # increase the loop counter by one
beq $t2, $s0, EXIT1 # if all the array elements are set up
addi $s4, $s4, 1 # increase the number by one
addu $t0, $t0, 4 # increase the pointer by four bytes
addu $t1, $t1, 4 # increase the pointer by four bytes
j loop1 # repeat to "loop1"
EXIT1: li $s2, 2
li $s6, 2
jal Eratosthenes # start recursive Eratosthenes
li $v0, 4 # system call #4
la $a0, NEWLINE
syscall
li $v0, 4 # system call #4
la $a0, NEWLINE
syscall
li $t2, 0 # reset the loop counter
la $t0, NUM_ARRAY # reset the address of the 1st array
la $t1, FLAG_ARRAY # reset the address of the 2nd array
loop3: lw $a0, ($t1) # load the number there
beq $a0, $zero, SKIP1 # if the target is '0': skip
beq $t2, $zero, SKIP1 # if repeated enough: skip
li $v0, 1 # system call #1
lw $a0, ($t0) # load the number there
syscall
li $v0, 4 # system call #4
la $a0, NEWLINE
syscall
SKIP1: addi $t2, $t2, 1 # increase the loop counter
addu $t0, $t0, 4 # increase the pointer by four bytes
addu $t1, $t1, 4 # increase the pointer by four bytes
blt $t2, $s0, loop3
li $v0, 4 # system call #4
la $a0, END_MSG
syscall
# restore registers ---------------------------------------
lw $ra, ($sp)
lw $s0, 4($sp)
lw $s1, 8($sp)
lw $s2, 12($sp)
lw $s4, 16($sp)
lw $s5, 20($sp)
lw $t0, 24($sp)
lw $t1, 28($sp)
lw $t2, 32($sp)
lw $v0, 36($sp)
lw $a0, 40($sp)
addu $sp, $sp, 48 # delete the stack frame
jr $31 # park it at the parking spot
# THE END OF MODULE MAIN ##########################################
Eratosthenes:
subu $sp,$sp,36
sw $ra, 0($sp)
sw $t5, 4($sp)
sw $t6, 8($sp)
sw $t0, 12($sp)
sw $t1, 16($sp)
sw $t2, 20($sp)
sw $s4, 24($sp)
sw $s5, 28($sp)
sw $s0, 32($sp)
li $s5, 0 #change s5 to 0
li $s6, 2 #reset the x
li $t2, 0
la $t0, NUM_ARRAY #reset Array 1
la $t1, FLAG_ARRAY #reset Array 2
R_Loop:
mult $s2,$s6
mflo $t7
addi $t2,$t2,1
lw $s4, ($t0)
beq $t7, $s4, SKIPone
beq $t2, $s0, EXITL #branch if counter is max
addu $t0, $t0, 4 #next spot in NUM_ARRAY
addu $t1, $t1, 4 #next spot in FLAG_ARRAY
li $v0,1
move $a0, $t7
syscall
li $v0,4
la $a0, NEWLINE
syscall
li $v0,4
la $a0, NEWLINE
syscall
j R_Loop
SKIPone:
addi $s6,$s6,1 #increment x by one
sw $zero, ($t1) #attempt at making position at array 0
#have also tried
#sw $s5, ($t1) #where s5 is initialized at 0
#please take note that offset is 0, because it needs to be
#at the current position at the array
li $v0,4
la $a0, NEWLINE
syscall
li $v0,4
la $a0, NEWLINE
syscall
li $v0,1
move $a0, $t4 #debug aid
syscall
li $v0,4
la $a0, NEWLINE
syscall
li $v0,4
la $a0, NEWLINE
syscall
beq $t2 $s0, EXITL
li $v0, 4
la $a0, INX #debug aid
syscall
j R_Loop
EXITL:
li $t8,10
li $v0, 4
la $a0, INK #debug aid
syscall
beq $s2,$t8, EXITR
addi $s2,$s2,1 #increment k by one
jal Eratosthenes
li $v0 4
la $a0, BUG1
syscall
EXITR:
lw $ra, 0($sp)
lw $t5, 4($sp)
lw $t6, 8($sp)
lw $t0, 12($sp)
lw $t1, 16($sp)
lw $t2, 20($sp)
lw $s4, 24($sp)
lw $s5, 28($sp)
lw $s0, 32($sp)
addu $sp,$sp,36
jr $ra
Any help is appreciated, nothing else seems to work and my teacher is of no help.
I'm working on a sorting program that sorts an array of integers, for which I copy the array entered in by the user into a new array to be mutated. However, I'm not sure if I'm doing it correctly.
.globl main
.data
input: .asciiz "Enter the size of the array: \n"
entries: .asciiz "Enter the elements of the array, one line at a time: \n"
output: .asciiz "Original array and then sorted array: \n"
space: .asciiz " "
.text
main:
subi $sp, $sp 32
sw $ra, 0($sp)
sw $t0, 4($sp) # the size of the array
sw $t4, 8($sp) # the number 4
sw $t1, 12($sp) # temporary
sw $t2, 16($sp) # array original
sw $t3, 20($sp) # specific element
sw $s1, 24($sp) # copied array
sw $t5, 28($sp) # number to copy
la $a0, input
li $v0, 4
syscall
# get the size
li $v0, 5
syscall
move $t0, $v0
# allocate space for the array on the heap
li $t4, 4
mul $t1, $t0, $t4
li $v0, 9
move $a0, $t1
syscall
move $t2, $v0
li $s0, 0
la $a0, entries
li $v0, 4
syscall
read_array:
# read element
li $v0, 5
syscall
move $t3, $v0
# place in right address
mul $t1, $s0, $t4
add $t1, $t2, $t1
sw $t3, 0($t2)
addi $s0, $s0, 1
blt $s0, $t0, read_array
li $s0, 0
gnome_sort:
# allocate space on heap for copy
mul $t1, $t0, $t4
li $v0, 9
move $a0, $t1
syscall
move $s1, $v0
mul $s2, $t4, $t0
add $s3, $s1, $s2
copy_array:
lw $t5, 0($t2)
sw $t5, 0($s1)
add $t2, $t2, $t4
add $s1, $s1, $t4
blt $s1, $s3, copy_array
li $s0, 0
while_loop:
bgt $s0, $t0, finish_sort
beq $s0, $zero, increase_i
sw $s4, 0($s1)
sw $s5, -4($s1)
bge $s4, $s5, increase_i
j swap_elements
increase_i:
addi $s0, $s0, 1
j while_loop
swap_elements:
la $a0, input
li $v0, 4
syscall
sw $t6, 0($s1)
sw $t7, -4($s1)
lw $t7, 0($s1)
lw $t6, -4($s1)
subi $s0, $s0, 1
j while_loop
finish_sort:
li $s0, 0
la $a0, output
li $v0, 4
syscall
j print_original
print_original:
bge $s0, $t0, print_sorted
lw $s6, 0($t2)
li $v0, 1
move $a0, $s6
syscall
la $a0, space
li $v0, 4
syscall
addi $s0, $s0, 1
j print_original
print_sorted:
li $s0, 0
loop:
bge $s0, $t0, finish
lw $s6, 0($s1)
li $v0, 1
move $a0, $s6
syscall
la $a0, space
li $v0, 4
syscall
addi $s0, $s0, 1
j loop
finish:
li $v0, 10
syscall
After testing this in QTSpim, it seems that you're going out of allocated memory on the line sw $s4, 0($s1)
in the while_loop. This is because $s1 at that point is past the end of the second array you allocated. If you want to use that memory, you will have to syscall for it.
The way you copy the array using lw and sw is correct.
In what particular cases we need to use lw/lh/lb?
strcpy:
addi $sp, $sp, -4
sw $s0,0($sp)
add $s0, $zero,$zero # $s0=0 i
addi $t1, $a1, $s0 #address of y
lbu $t2, 0($t1) #$t2=y[]
addi $t3, $a0,$s0 #address of x
sb $t2,0($t3)
beq $t3, $zero, L2
addi $s0, $s0, 1
j L1
L2: lw $s0, 0($sp)
addi $sp, $sp, 4
jr $ra
this is the code that gives example of using lbu, but why not to use lw instead of lw or can we use here lh?Can you please explain the concepts behind using different opcodes?Thank you very much in advance=)
here is the code in C
Void mm ( double a[][]), double b[][], double c[][])
{
int i, j, k;
for (i=0; i! = 3; i = i+1){
for (j = 0; j! = 3; j = j+1){
d[i][j] = a[i][j] ;
for (k = 0; k! = 3; k = k+1){
d[i][j] = d[i][j] + b[i][k] * c[k][j];
}
}
}
}
also keep in mind that I have to read the data of arrays a,b,c and then print array d
and here is my assembly code
.data
arrA: .space 72
arrB: .space 72
arrC: .space 72
arrD: .space 72
bracA: .asciiz "a("
bracB: .asciiz "b("
bracC: .asciiz "c("
bracD: .asciiz "d("
comma: .asciiz ","
endBrac: .asciiz ")= "
nextLine: .asciiz "\n"
.text
.globl main
main:
addi $sp, $sp, -32 #Make space of stack
sw $ra, 20($sp) #Store $ra
la $a1, arrA #load base of Array a
la $a2, arrB #load base of Array b
la $a3, arrC #load base of Array c
la $t7, arrD #load base of Array d
li $s0, 1 #set i
li $s1, 1 #set j
li $s2, 1 #set k
li $s7, 1 #counter
loopi:
slti $t0, $s0, 4 #Check i<4
beq $t0, $zero, nextArr #If i=4 go nextArr
loopj:
slti $t0, $s1, 4 #Check j<4
beq $t0, $zero, nextRow #If i=4 go nextRow
slti $t1, $s7, 4 #Check counter
beq $t1, $zero, contB #if counter >=4 go to contB
li $v0, 4 #Prepare for print string
la $a0, bracA #Load adress of string "a("
syscall
j cont
contB:
slti $t1, $s7, 7
beq $t1, $zero, contC #if counter>=7 go to contC
li $v0, 4
la $a0, bracB
syscall
j cont
contC:
slti $t1, $s7, 10
beq $t1, $zero, calcD
li $v0, 4
la $a0, bracC
syscall
cont:
li $v0, 1 #prepare to print integer
move $a0, $s0 #print i
syscall
li $v0, 4
la $a0, comma
syscall
li $v0, 1
move $a0, $s1 #print j
syscall
li $v0, 4
la $a0, endBrac
syscall
sll $t0, $s0, 1 #t0=2*i
add $t0, $t0, $s0 #t0=3*i
add $t0, $t0, $s1 #t0=3*i +j
sll $t0, $t0, 3 #t0=(3*i +j)*8 create double precision
slti $t1, $s7, 4
beq $t1, $zero, useA2
add $t0, $t0, $a1 #a1=base address of a array
j contLi
useA2:
slti $t1, $s7, 7
beq $t1, $zero, useA3
add $t0, $t0, $a2 #a2=base address of a array
j contLi
useA3:
add $t0, $t0, $a3 #a3=base address of a array
contLi:
li $v0, 7
syscall
s.d $f0, 0($t0) #store $t0 to $f0 as floating point
l.d $f12, 0($t0)
li $v0, 3 #get ready to print double
syscall
addi $s1, $s1, 1 #increase j
li $v0, 4
la $a0, nextLine
syscall
j loopj
nextRow:
addi $s7, $s7, 1 #increase counter
addi $s0, $s0, 1 #increase i
li $s1, 1 #set j=1
j loopi
nextArr:
li $s0, 1 #set i=1
li $s1, 1 #set j=1
j loopi
calcD:
li $s0, 1 #set i,j,k=1 for calculations
li $s1, 1
li $s2, 1
li $t0, 0
li $t1, 0
li $t2, 0
li $t3, 0
outLoop:
slti $t0, $s0, 4 #Loop that count i
beq $t0, $zero, printRes
inLoop1:
slti $t0, $s1, 4 #loop that count j
beq $t0, $zero, finInLoop1
sll $t0, $s0, 1 #t0=2*i
add $t0, $t0, $s0 #t0=3*i
add $t0, $t0, $s1 #t0=3*i +j
sll $t0, $t0, 3 #t0=(3*i +j)*8 (double precision)
add $t0, $t0, $a1 #a1=base address of a array
sll $t1, $s0, 1 #t3=2*i
add $t1, $t1, $s0 #t3=3*i
add $t1, $t1, $s1 #t3=3*i +j
sll $t1, $t1, 3 #t3=(3*i +j)*8 for double precision
add $t1, $t1, $t7 #t4=base address of d array
mtc1 $zero,$f0 #f8=sum to be stored in d[i][j](initial value before k loops=0)
cvt.d.w $f0, $f0
mov.d $f8, $f0
l.d $f2, 0($t0) #Load $t0 to $f2
inLoop2:
slti $t4, $s2, 4 #Loop that count k
beq $t4, $zero, finInLoop2
sll $t2, $s0, 1 #t1=2*i
add $t2, $t2, $s0 #t1=3*i
add $t2, $t2, $s2 #t1=3*i +k
sll $t2, $t2, 3 #t1=(3*i +k)*8 (double precision)
add $t2, $t2, $a2 #a2=base address of b array
sll $t3, $s2, 1 #t2=2*k
add $t3, $t3, $s2 #t2=3*k
add $t3, $t3, $s1 #t2=3*k +j
sll $t3, $t3, 3 #t2=(3*k +j)*8 for double precision
add $t3, $t3, $a3 #a3=base address of c array
#So far, t0=address of a[i][j], t1=address of b[i][k], t2=address of c[k][j] and t3=address of d[i][j]
l.d $f4, 0($t2) #Load $t2 to $f4
l.d $f6, 0($t3) #Load $t3 to $f6
mul.d $f10, $f4, $f6
add.d $f8, $f8, $f10
addi $s2, $s2, 1
j inLoop2
finInLoop2:
add.d $f8, $f8, $f2
s.d $f8, 0($t1)#store total sum in d[i][j]
addi $s1, $s1, 1
li $s2, 1 #k=1 to start loop for next j
add.d $f8, $f8, $f0
j inLoop1
finInLoop1:
addi $s0, $s0, 1
li $s1, 1# j=1 to start loop for next i
j outLoop
printRes:
li $s0, 1 #initial value of i=1
li $s1, 1 #initial value of j=1
li $s2, 1 #initial value of k=1
printLoop1:
slti $t0, $s0, 4
beq $t0, $zero, Exit
slti $t0, $s1, 4
beq $t0, $zero, printLoop2
li $v0, 4
la $a0, nextLine
syscall
li $v0, 4
la $a0, bracD
syscall
li $v0, 1
move $a0, $s0
syscall
li $v0, 4
la $a0, comma
syscall
li $v0, 1
move $a0, $s1
syscall
li $v0, 4
la $a0, endBrac
syscall
sll $t0, $s0, 1 #t0=2*i
add $t0, $t0 $s0 #t0=3*i
add $t0, $t0, $s1 #t0=3*i +j
sll $t0, $t0, 3 #t0=(3*i +j)*8 (double precision)
add $t0, $t0, $t7 #t4=base address of d array
l.d $f12, 0($t0)
li $v0, 3 #get ready to print double
syscall
addi $s1, $s1, 1
j printLoop1
printLoop2:
addi $s0, $s0, 1
li $s1, 1
j printLoop1
Exit:
jr $ra
when I read the data
the program prints instantly what I have written
and it doesn't print in the end the d array
I'm a beginner in mips assembly so there might be some major problems with my code
but I can't find them...