drawing a picture of stack at each step showing in what direction the stack grow

Question

drawing a picture of stack at each step showing in what direction the stack grows.

What precautions should one take to ensure that stack memory space does not overlap with instruction memory?

If your delay function is not accurate calculate the error %age and discuss the possible reasons for the inaccuracy.

; Task 1
;CLRA
;CLRB
;LDAA #2
;LDAB #4
;JSR AREA
;ORG $4100
;AREA:
;MUL
;RTS
  
; Task 4
LDAB #255
STAB DDRB
STAB DDRJ
CLR PTJ
  
START:
LDAB #85
STAB PORTB
  
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
  
LDAB #170
STAB PORTB
  
  
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
LDAA #250
JSR DELAY
  
JMP START
  
; Task 3
;LDAA #10
;JSR DELAY
ORG $4200
STAA $1100
DELAY:
LOOPOUT:
LDAB #250
LOOPIN:
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
MOVB $1100, $1101
NOP
NOP
DECB
BNE LOOPIN
DECA
BNE LOOPOUT
RTS
  
  

Explanation / Answer

.text
main:
j mm

mm:
la $a3, array_A # base address for array_A loaded into $a3
la $a1, array_B # base address for array_B loaded into $a1
la $a2, array_C # base address for array_C loaded into $a2

li $t1, four # $t1 = four (row-size and loop end)
li $s0, zero # i = 0; initialize first for loop
loop1:
li $s1, zero # j = 0; restart 2d for loop
loop2:
li $s2, zero # k = 0; restart third for loop
sll $t2, $s0, a pair of # $t2 = i * four (size of row of c)
addu $t2, $t2, $s1 # $t2 = i * size(row) + j
sll $t2, $t2, a pair of # $t2 = computer memory unit offset of [i][j]
addu $t2, $a2, $t2 # $t2 = computer memory unit offset of [i][j]
lw $t4, 0($t2) # $t4 = a pair of bytes of c[i][j]
loop3:
sll $t0, $s2, a pair of # $t0 = k * four (size of row of b)
addu $t0, $t0, $s1 # $t0 = k * size(row) + j
sll $t0, $t0, a pair of # $t0 = computer memory unit offset off [k][j]
addu $t0, $a1, $t0 # $t0 = computer memory unit address of b[k][j]
lw $t5, 0($t0) # $t5 = a pair of bytes of b[k][j]
sll $t0, $s0, a pair of # $t0 = i * four (size of row of a)
addu $t0, $t0, $s2 # $t0 = i * size(row) + k
sll $t0, $t0, a pair of # $t0 = computer memory unit offset of [i][k]
addu $t0, $a3, $t0 # $t0 = computer memory unit address of a[i][k]
lw $t6, 0($t0) # $t6 = a pair of bytes of a[i][k]
mul $t5, $t6, $t5 # $t5 = a[i][k] * b[k][j]
add $t4, $t4, $t5 # $t4 = c[i][j] + a[i][k] * b[k][j]
addiu $s2, $s2, one # $k = k + one
bne $s2, $t1, loop3 #if (k != 4) head to loop3
sw $t4, 0($a2) # c[i][j] = $t4
#----------TEST-------------
li $v0, 1
lw $a0, ($a2)
syscall
li $v0, 4
la $a0, new_row
syscall
#----------TEST-------------

addiu $s1, $s1, one # $j = j + one
addi $a2, $a2, 4
bne $s1, $t1, loop2 # if (j != 4) head to loop2

addiu $s0, $s0, one # $i = i + one
bne $s0, $t1, loop1 # if (i != 32) head to L1

Exit:
li $v0, 10 #exits
syscall

.data
array_A: .word 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
array_B: .word 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
array_C: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
output_row_string_C: .asciiz "Matrix C Output Row "
colon_string: .asciiz ":
space_string: .asciiz " "
new_row: .asciiz " "
char_space: .space 2

Related Questions

Navigate

• Browse (All)
• Browse D
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.