Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
41 views

CSCI-365 Computer Organization

The document discusses loops, inequalities, immediates, and other concepts in MIPS assembly language. It provides examples of compiling C code constructs like if/else statements, for loops, and switch statements into equivalent MIPS code. It also gives a worked example of finding the maximum value in an integer array.

Uploaded by

SebastianAlbertoRodriguez
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
41 views

CSCI-365 Computer Organization

The document discusses loops, inequalities, immediates, and other concepts in MIPS assembly language. It provides examples of compiling C code constructs like if/else statements, for loops, and switch statements into equivalent MIPS code. It also gives a worked example of finding the maximum value in an integer array.

Uploaded by

SebastianAlbertoRodriguez
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 18

CSCI-365

Computer Organization
Lecture 4

Note: Some slides and/or pictures in the following are adapted from:
Computer Organization and Design, Patterson & Hennessy, ©2005
Some slides and/or pictures in the following are adapted from:
slides ©2008 UCB
Loops in C/Assembly

• Compile into MIPS; A[] is an array of ints


do {
g = g + A[i];
i = i + j;
} while (i != h);
• Use this mapping:
g, h, i, j, base of A
$s1, $s2, $s3, $s4, $s5
(done in class)
Loops in C/Assembly

• There are three types of loops in C:


– while
– do… while
– for
• Each can be rewritten as either of the other two, so the
method used in the previous example can be applied to
while and for loops as well
• Key Concept: Though there are multiple ways of writing
a loop in MIPS, the key to decision making is conditional
branch
Inequalities in MIPS
• Until now, we’ve only tested equalities
(== and != in C). General programs need to test < and > as well
• Create a MIPS Inequality Instruction:
– “Set on Less Than”
– Syntax: slt reg1,reg2,reg3
– Meaning: reg1 = (reg2 < reg3);
if (reg2 < reg3)
reg1 = 1; Same thing…
else reg1 = 0;
– “set” means “set to 1”,
“reset” means “set to 0”
Register Zero

• The number zero (0), appears very often in code


• MIPS defines register zero ($0 or $zero) to always
have the value 0; eg
add $s0,$s1,$zero (in MIPS)
f = g (in C)
where MIPS registers $s0,$s1 are associated with C variables
f, g
Immediates

• Immediates are numerical constants


• They appear often in code, so there are special
instructions for them
• Add Immediate:
addi $s0,$s1,10 (in MIPS)
f = g + 10 (in C)
where MIPS registers $s0,$s1 are associated with C variables
f, g
• Syntax similar to add instruction, except that last
argument is a number instead of a register
Immediates

• There is no Subtract Immediate in MIPS: Why?


• Limit types of operations that can be done to absolute
minimum
– if an operation can be decomposed into a simpler operation,
don’t include it
– addi …, -X = subi …, X => so no subi
• addi $s0,$s1,-10 (in MIPS)
f = g - 10 (in C)
where MIPS registers $s0,$s1 are associated with C variables
f, g
Inequalities in MIPS
• How do we use this? Compile by hand:

if (g < h) goto Less; #g:$s0, h:$s1


• Answer: compiled MIPS code…
slt $t0,$s0,$s1 # $t0 = 1 if g<h
bne $t0,$0,Less # goto Less
# if $t0!=0
# (if (g<h)) Less:
• Branch if $t0 != 0  (g < h)
• Register $0 always contains the value 0, so bne and beq often use
it for comparison after an slt instruction.
• A slt  bne pair means if(… < …)goto…
Immediates in Inequalities
• There is also an immediate version of slt to test against constants:
slti
– Helpful in for loops
C if (g >= 1) goto Loop
Loop: . . .
M slti $t0,$s0,1 # $t0 = 1 if
I # $s0<1 (g<1)
P beq $t0,$0,Loop # goto Loop
# if $t0==0
S # (if (g>=1))
Inequalities in MIPS

• Now, we can implement <, but how do we


implement >, ≤ and ≥ ?
• We could add 3 more instructions, but:
– MIPS goal: Simpler is Better
• Can we implement ≤ in one or more instructions
using just slt and the branches? (done in class)
• What about >? (done in class)
• What about ≥? (done in class)
Compiling if-then-else Statements
Show a sequence of MIPS instructions corresponding to:
if (i<=j) x = x+1; z = 1; else y = y–1; z = 2*z
// j: $s2, i:$s1, x:$t1, z:$t3, y:$t2,

Solution
Similar to the “if-then” statement, but we need instructions for the
“else” part and a way of skipping the “else” part after the “then” part.
slt $t0,$s2,$s1 # j<i? (inverse condition)
bne $t0,$zero,else # if j<i goto else part
addi $t1,$t1,1 # begin then part: x = x+1
addi $t3,$zero,1 # z = 1
j endif # skip the else part
else: addi $t2,$t2,-1 # begin else part: y = y–1
add $t3,$t3,$t3 # z = z+z
endif:...
The For Example

for (i = 0; i < size; i += 1)


array[i] = 0;
// i:$t0, array starts at $a0, size:$a1

addi $t0,$zero,0 # i = 0
loop1: sll $t1,$t0,2 # $t1 = i * 4
add $t2,$a0,$t1 # $t2 = &array[i]
sw $zero, 0($t2) # array[i] = 0
addi $t0,$t0,1 # i = i + 1
slt $t3,$t0,$a1 # $t3 = (i < size)
bne $t3,$zero,loop1 # if (…) goto loop1
Example: The C Switch Statement

• Choose among four alternatives depending on


whether k has the value 0, 1, 2 or 3. Compile
this C code:

switch (k) {
case 0: f=i+j; break; /* k=0 */
case 1: f=g+h; break; /* k=1 */
case 2: f=g–h; break; /* k=2 */
case 3: f=i–j; break; /* k=3 */
}
Example: The C Switch Statement

• This is complicated, so simplify


• Rewrite it as a chain of if-else statements, which we
already know how to compile:
if(k==0) f=i+j;
else if(k==1) f=g+h;
else if(k==2) f=g–h;
else if(k==3) f=i–j;
• Use this mapping:
f:$s0, g:$s1, h:$s2,
i:$s3, j:$s4, k:$s5
Example: The C Switch Statement
• Final compiled MIPS code:

bne $s5,$0,L1 # branch k!=0


add $s0,$s3,$s4 # k==0 so f=i+j
j Exit # end of case so Exit
L1: # $t0=k-1
# branch k!=1
# k==1 so f=g+h
# end of case so Exit
L2: # $t0=k-2
# branch k!=2
# k==2 so f=g-h
# end of case so Exit
L3: # $t0=k-3
# branch k!=3
#k==3 so f=i-j
Exit:
Example: The C Switch Statement
• Final compiled MIPS code:

bne $s5,$0,L1 # branch k!=0


add $s0,$s3,$s4 # k==0 so f=i+j
j Exit # end of case so Exit
L1: addi $t0,$s5,-1 # $t0=k-1
bne $t0,$0,L2 # branch k!=1
add $s0,$s1,$s2 # k==1 so f=g+h
j Exit # end of case so Exit
L2: addi $t0,$s5,-2 # $t0=k-2
bne $t0,$0,L3 # branch k!=2
sub $s0,$s1,$s2 # k==2 so f=g-h
j Exit # end of case so Exit
L3: addi $t0,$s5,-3 # $t0=k-3
bne $t0,$0,Exit # branch k!=3
sub $s0,$s3,$s4 #k==3 so f=i-j
Exit:
Finding the Maximum Value in a List of Integers
List A is stored in memory beginning at the address given in $s1.
List length is given in $s2.
Find the largest integer in the list and copy it into $t0.

Solution
Scan the list, holding the largest element identified thus far in $t0.
# initialize maximum to A[0]
# initialize index i to 0
loop: # increment index i by 1
# if all elements examined, quit
# compute 2i in $t2
# compute 4i in $t2
# form address of A[i] in $t2
# load value of A[i] into $t3
# maximum < A[i]?
# if not, repeat with no change
# if so, A[i] is the new maximum
# change completed; now repeat
done: ... # continuation of the program
Finding the Maximum Value in a List of Integers
List A is stored in memory beginning at the address given in $s1.
List length is given in $s2.
Find the largest integer in the list and copy it into $t0.

Solution
Scan the list, holding the largest element identified thus far in $t0.
lw $t0,0($s1) # initialize maximum to A[0]
addi $t1,$zero,0 # initialize index i to 0
loop: add $t1,$t1,1 # increment index i by 1
beq $t1,$s2,done # if all elements examined, quit
add $t2,$t1,$t1 # compute 2i in $t2
add $t2,$t2,$t2 # compute 4i in $t2
add $t2,$t2,$s1 # form address of A[i] in $t2
lw $t3,0($t2) # load value of A[i] into $t3
slt $t4,$t0,$t3 # maximum < A[i]?
beq $t4,$zero,loop # if not, repeat with no change
addi $t0,$t3,0 # if so, A[i] is the new maximum
j loop # change completed; now repeat
done: ... # continuation of the program

You might also like