 |
CS 3723 Programming Languages |
MIPS Example: Loop | |
| C, Tiny, Output | MIPS Assembly Code |
|---|---|
#include <stdio.h>
int main() {
double n, s, m;
n = 1; s = 0;
scanf("%lf", &m);
while (n - m != 0) {
s = s + 1/(n*n);
printf("%.0f\t%.17f\n", n, s);
n = n + 1;
}
}
| ### Compiled on: Tue Sep 24, 2013
main: addu $s7, $ra, $zero
# addr of M: constants, vars, temps
la $s1, M
### Start of compiled code
# M[23] = M[1]
l.d $f2, 8($s1)
s.d $f2, 184($s1)
# M[28] = M[0]
l.d $f2, 0($s1)
s.d $f2, 224($s1)
# Read M[22] as double
li $v0, 7
syscall
s.d $f0, 176($s1)
WhileStart0:
# M[36] = M[23] - M[22]
l.d $f2, 184($s1)
l.d $f4, 176($s1)
sub.d $f6, $f2, $f4
s.d $f6, 288($s1)
l.d $f2, 288($s1)
l.d $f4, 0($s1)
c.eq.d $f2, $f4
bc1t WhileEnd0
# M[37] = M[23] * M[23]
l.d $f2, 184($s1)
l.d $f4, 184($s1)
mul.d $f6, $f2, $f4
s.d $f6, 296($s1)
# M[38] = M[1] / M[37]
l.d $f2, 8($s1)
l.d $f4, 296($s1)
div.d $f6, $f2, $f4
s.d $f6, 304($s1)
# M[39] = M[28] + M[38]
l.d $f2, 224($s1)
l.d $f4, 304($s1)
add.d $f6, $f2, $f4
s.d $f6, 312($s1)
# M[28] = M[39]
l.d $f2, 312($s1)
s.d $f2, 224($s1)
# Print M[23]
li $v0, 3
l.d $f12, 184($s1)
syscall
# Print Tab as ASCII char
li $v0, 4
la $a0, Tab
syscall
# Print M[28]
li $v0, 3
l.d $f12, 224($s1)
syscall
# Print NewL as ASCII char
li $v0, 4
la $a0, NewL
syscall
# M[40] = M[23] + M[1]
l.d $f2, 184($s1)
l.d $f4, 8($s1)
add.d $f6, $f2, $f4
s.d $f6, 320($s1)
# M[23] = M[40]
l.d $f2, 320($s1)
s.d $f2, 184($s1)
j WhileStart0
WhileEnd0:
### End of complied code
addu $ra, $s7, $zero
jr $ra
.data
.align 3
M: .double 0.,1.,2.,3.,4.,5.,6.
.double 7.,8.,9. # constants
.space 208 # variables a to z
.space 1000 # 125 temporaries
Blank: .asciiz " "
NewL: .asciiz "\n"
Tab: .asciiz "\t"
### End of MIPS source
|
- The Loop: From the Tiny code, this loop has the termination
condition n - m == 0, where as with C the "equals zero" part
is implied. The loop starts with the "WhileStart0" label and
ends with "WhileEnd0". The instruction bc1t WhileEnd0
is the last part of the while condition, just before the loop body.
You should check for yourself where in the code the value of
n - m is placed into a register and how it is subsequently
checked against 0.0 for equality.
Loops using the integer features of MIPS can use branch instructions
that directly work based on a comparison of registers.
The floating point loops require branches that require and earlier
instruction to set a "condition code" and then do a conditional
branch based on the code. (So the floating point branches are more
like those of a "normal" assembly language.
Two instructions carry out the conditional branch based on
whether or not n - m is 0.0:
c.eq.d $f2, $f4 bc1t WhileEnd0
c.eq.d cc fs, ft"Compare the floating-point double in register fs against the one in ft and set the floating-point condition flag cc to 1 if they are equal. If cc is omitted, condition code flag 0 is assumed." In our case the cc is omitted. The bc1t instruction is described on page A-60 of Appendix A. There, is says, among other things, in describing
bc1t cc label"Conditionally branch [to label] if the floating point coprocessor's condition flag numbered cc is true. If cc is omitted from the instruction, condition code flag 0 is assumed." Again in our case the cc is omitted. You can now work out (with some thought and struggle) that these instructions do what we want. Notice that the instruction bc1f is available to reverse true and false.