Scribd
Upload
72 views7 pages

Sheet 1 Solution

This document contains solutions to computer architecture questions from Alexandria University's Faculty of Engineering. The solutions involve MIPS assembly code for tasks like copying strings, comparing numbers, and converting between big-endian and little-endian formats. Registers and the stack are used to pass parameters and save return addresses for function calls.

Uploaded by

Omar Essam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
72 views7 pages

Sheet 1 Solution

This document contains solutions to computer architecture questions from Alexandria University's Faculty of Engineering. The solutions involve MIPS assembly code for tasks like copying strings, comparing numbers, and converting between big-endian and little-endian formats. Registers and the stack are used to pass parameters and save return addresses for function calls.

Uploaded by

Omar Essam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Alexandria University Spring 2021

Faculty of Engineering CC - Computer Architecture

Specialized Scientific Programs Sheet 1 solution

Computer and Communications

Engineering Program

Sheet 1 solution

Question 1:
# Big-endian

li $t0, 0xABCD9876

sw $t0, 100($0)

lb $s5, 101($0) # the LSB of $s5 = 0xCD

# Little-endian

li $t0, 0xABCD9876

sw $t0, 100($0)

lb $s5, 101($0) # the LSB of $s5 = 0x98

In big-endian format, the bytes are numbered from 100 to 103 from left to

right. In little-endian format, the bytes are numbered from 100 to 103 from right

to left. Thus, the final load byte (lb) instruction returns a different value de-

pending on the endianness of the machine.

Question 2 :

0x20100049

0xad49fff9

0x02f24822

Prof. Dr. Mohamed Rizk Eng. Omnia BadrEldin

Dr. Ali Gaber Eng. Nada Khalil


Question 3:

(a) # $s0 = g, $s1 = h

slt $t0, $s1, $s0 # if h < g, $t0 = 1

beq $t0, $0, else # if $t0 == 0, do else

add $s0, $s0, $s1 #g=g+h

j done # jump past else block

else:sub $s0, $s0, $s1 # g = g - h

done:

b)

slt $t0, $s0, $s1 # if g < h, $t0 = 1

bne $t0, $0, else # if $t0 != 0, do else

addi $s0, $s0, 1 # g = g + 1

j done # jump past else block

else: addi $s1, $s1, -1 # h = h - 1

done:

(c)

slt $t0, $s1, $s0 # if h < g, $t0 = 1

bne $t0, $0, else # if $t0 != 0, do else

add $s0, $0, $0 # g = 0

j done # jump past else block

else: sub $s1, $0, $0 # h = 0

done:
Question 4 :

(a)
# MIPS assembly code

# base address of array dst = $a0

# base address of array src = $a1

# i = $s0

strcpy:

addi $sp, $sp, -4

sw $s0, 0($sp) # save $s0 on the stack

add $s0, $0, $0 # i = 0

loop:

add $t1, $a1, $s0 # $t1 = address of src[i]

lb $t2, 0($t1) # $t2 = src[i]

add $t3, $a0, $s0 # $t3 = address of dst[i]

sb $t2, 0($t3) # dst[i] = src[i]

beq $t2, $0, done # check for null character

addi $s0, $s0, 1 # i++

j loop

done:

lw $s0, 0($sp) # restore $s0 from stack

addi $sp, $sp, 4 # restore stack pointer

jr $ra # return

(b) The stack (i) before, (ii) during, and (iii) after the strcpy procedurecall.
Question 5:
(a) The stack frames of each procedure are:
proc1: 3 words deep (for $s0 - $s1, $ra)
proc2: 7 words deep (for $s2 - $s7, $ra)
proc3: 4 words deep (for $s1 - $s3, $ra)
proc4: 0 words deep (doesn't use any saved registers or call other procedures)

(b) Note: we arbitrarily chose to make the initial value of the stack pointer
0x7FFFFF04 just before the procedure calls.

Question 6:
(a) 000100 01000 10001 0000 0000 0000 0010
= 0x11110002
(b) 000100 01111 10100 0000 0100 0000 1111
= 0x11F4040F
(c) 000100 11001 10111 1111 1000 0100 0010
= 0x1337F842
(d) 000011 0000 0100 0001 0001 0100 0111 11
= 0x0C10451F
Question 7:

(a)
set_array: addi $sp,$sp,-52 # move stack pointer
sw $ra,48($sp) # save return address
sw $s0,44($sp) # save $s0
sw $s1,40($sp) # save $s1
add $s0,$0,$0 # i = 0
addi $s1,$0,10 # max iterations = 10
loop: add $a1,$s0,$0 # pass i as parameter
jal compare # call compare(num, i)
sll $t1,$s0,2 # $t1 = i*4
add $t2,$sp,$t1 # $t2 = address of array[i]
sw $v0,0($t2) # array[i] = compare(num, i);
addi $s0,$s0,1 # i++
bne $s0,$s1,loop # if i<10, goto loop
lw $s1,40($sp) # restore $s1
lw $s0,44($sp) # restore $s0
lw $ra,48($sp) # restore return address
addi $sp,$sp,52 # restore stack pointer
jr $ra # return to point of call

compare: addi $sp,$sp,-4 # move stack pointer


sw $ra,0($sp) # save return address on the stack
jal subtract # input parameters already in $a0,$a1
slt $v0,$v0,$0 # $v0=1 if sub(a,b) < 0 (return 0)
slti $v0,$v0,1 # $v0=1 if sub(a,b)>=0, else $v0 = 0
lw $ra,0($sp) # restore return address
addi $sp,$sp,4 # restore stack pointer
jr $ra # return to point of call
subtract: sub $v0,$a0,$a1 # return a-b
jr $ra # return to point of call

b)
(c) If $ra were never stored on the stack, the compare function would re-
turn to the instruction after the call to subtract (slt $v0,$v0,$0 ) in-
stead of returning to the set_array function. The program would enter an
infinite loop in the compare function between jr $ra and slt $v0,
$v0, $0. It would increment the stack during that loop until the stack space
was exceeded and the program would likely crash.
Question 8:
# high-level code
void little2big(int[] array)
{
int i;
for (i = 0; i < 10; i = i + 1) {
array[i] = ((array[i] & 0xFF) << 24) ||
(array[i] & 0xFF00) << 8) ||
(array[i] & 0xFF0000) >> 8) ||
((array[i] >> 24) & 0xFF));
}
}

# MIPS assembly code


# $a0 = base address of array
little2big:
addi $t5, $0, 10 # $t5 = i = 10 (loop counter)
loop: lb $t0, 0($a0) # $t0 = array[i] byte 0
lb $t1, 1($a0) # $t1 = array[i] byte 1
lb $t2, 2($a0) # $t2 = array[i] byte 2
lb $t3, 3($a0) # $t3 = array[i] byte 3
sb $t3, 0($a0) # array[i] byte 0 = previous byte 3
sb $t2, 1($a0) # array[i] byte 1 = previous byte 2
sb $t1, 2($a0) # array[i] byte 2 = previous byte 1
sb $t0, 3($a0) # array[i] byte 3 = previous byte 0
addi $a0, $a0, 4 # increment index into array
addi $t5, $t5, -1 # decrement loop counter
beq $t5, $0, done
j loop
done:

You might also like