Monash University > School of Computer Science and Software Engineering > CSE1303 > Part B > Lectures > Lecture B16 notes
# Do it 10 times.
sw $0, x
loop: lw $t0, x
beq $t0, 10, end
# body of loop: n steps
lw $t0, x
add $t0, $t0, 1
sw $t0, x
j loop
end: rest of program ...
|
# Do it 10 times.
sw $0, x
loop: # body of loop: n steps
lw $t0, x
add $t0, $t0, 1
sw $t0, x
lw $t0, x
bne $t0, 10, loop
# rest of program ...
|
la $t0, source
la $t1, dest
loop: lbu $t2, 0($t0) # Copy
sb $t2, 0($t1) # char.
beq $t2, 0, end # Ended?
add $t0, $t0, 1 # Next
add $t1, $t1, 1 # char.
j loop
end: # rest of program ...
|
la $t0, source
la $t1, dest
loop: lbu $t2, 0($t0) # Copy
sb $t2, 0($t1) # char.
beq $t2, 0, end # Ended?
lbu $t2, 1($t0) # Next
sb $t2, 1($t1) # char.
beq $t2, 0, end # Ended?
add $t0, $t0, 2 # Jump
add $t1, $t1, 2 # by 2.
j loop
end: # rest of program ...
|
switch (n)
{
case 0: /* code for zero */
break;
case 1: /* code for one */
break;
case 4: /* code for four */
break;
case 5: /* code for five */
break;
default: /* default code */
break;
}
|
lw t0, n
beq $t0, 0, zero
beq $t0, 1, one
beq $t0, 4, four
beq $t0, 5, five
j default
zero: # code for zero
j end
one: # code for one
j end
four: # code for four
j end
five: # code for five
j end
default: # default code
j end
end: # rest of code...
|
.data
jtable: .word zero, one, default
.word default, four, five
.text
lw t0, n
blt $t0, 0, default
bgt $t0, 5, default
sll $t0, $t0, 2
lw $t0, jtable($t0)
jr $t0
zero: # code for zero
j end
one: # code for one
j end
four: # code for four
j end
five: # code for five
j end
default: # default code
j end
end: # rest of code...
|
# This version keeps a variable
# on stack.
main: move $fp, $sp
subu $sp, $sp, 4
li $v0, 5
syscall
sw $v0, -4($fp)
loop: lw $t0, -4($fp)
blt $t0, $zero, end
# Do something: n steps.
lw $t0, -4($fp)
sub $t0, $t0, 1
sw $t0, -4($fp)
j loop
end: li $v0, 10
syscall
|
# This version keeps a variable
# in a register ($s0).
main: move $fp, $sp
li $v0, 5
syscall
move $s0, $v0
loop: blt $s0, $zero, end
# Do something: n steps.
sub $s0, $s0, 1
j loop
end: li $v0, 10
syscall
|
/* String copy using arrays. */
char *strcpy(char s[], char t[])
{
int i = 0;
while ((s[i] = t[i]) != '\0')
{
i++;
}
return s;
}
|
# strcpy function in MIPS.
# Variables kept in registers:
# i in $t9, s in $t4, t in $t5.
strcpy: subu $sp, $sp, 8
sw $ra, 4($sp)
sw $fp, 0($sp)
move $fp, $sp
move $t9, $zero # i
lw $t4, 8($fp) # s
lw $t5, 12($fp) # t
loop: add $t0, $t5, $t9
lbu $t1, 0($t0) # t[i]
add $t0, $t4, $t9
sb $t1, 0($t0) # s[i]
beq $t1, 0, end
add $t9, $t9, 1 # i++
j loop
end: lw $v0, 8($fp) # s
lw $fp, 0($sp)
lw $ra, 4($sp)
addu $sp, $sp, 8
jr $ra
|
/* String copy using pointers. */
char *strcpy(char *s, char *t)
{
char *r = s;
while ((*s = *t) != '\0')
{
s++; t++;
}
return r;
}
|
# strcpy function in MIPS.
# Variables kept in registers:
# r in $t8, s in $t4, t in $t5.
strcpy: subu $sp, $sp, 8
sw $ra, 4($sp)
sw $fp, 0($sp)
move $fp, $sp
move $t8, $t4 # r
lw $t4, 8($fp) # s
lw $t5, 12($fp) # t
loop: lbu $t1, 0($t5) # *t
sb $t1, 0($t4) # *s
beq $t1, 0, end
add $t4, $t4, 1 # s++
add $t5, $t5, 1 # t++
j loop
end: move $v0, $t8 # r
lw $fp, 0($sp)
lw $ra, 4($sp)
addu $sp, $sp, 8
jr $ra
|
# Calling a function ...
.text
main: move $fp, $sp
subu $sp, $sp, 4 # local
# Call func(local, 42)
subu $sp, $sp, 8
li $t0, -4($fp) # local
sw $t0, 0($sp) # arg 1
li $t0, 42
sw $t0, 4($sp) # arg 2
jal func
addu $sp, $sp, 8
# more code ...
|
# A function ...
func: subu $sp, $sp, 8
sw $ra, 4($sp)
sw $fp, 0($sp)
move $fp, $sp
# code that uses
# params at 8($fp)
# and 12($fp)
lw $fp, 0($sp)
lw $ra, 4($sp)
addu $sp, $sp, 8
jr $ra
|
# Calling a function ...
.text
main: move $fp, $sp
subu $sp, $sp, 4 # local
# Pretend to call
# func(local, 42).
# Code that uses
# value at -4($fp)
# and constant 42.
# more code ...
|
void remquo(int num, int den,
int *remPtr, int *quoPtr);
int main()
{
int a, b, c, d;
scanf("%d%d", &a, &b);
remquo(a, b, &c, &d);
printf("%d %d\n", c, d);
}
void remquo(int num, int den,
int *remPtr, int *quoPtr)
{
*quoPtr = num / den;
*remPtr = num % den;
}
|
.text
main: move $fp, $sp
subu $sp, $sp, 16
# Read a and b.
li $v0, 5
syscall
sw $v0, -16($fp) # a
li $v0, 5
syscall
sw $v0, -12($fp) # b
# Call remquo.
subu $sp, $sp, 16
lw $t0, -16($fp) # a
sw $t0, 0($sp) # arg 1
lw $t0, -12($fp) # b
sw $t0, 4($sp) # arg 2
la $t0, -8($fp) # &c
sw $t0, 8($sp) # arg 3
la $t0, -4($fp) # &d
sw $t0, 12($sp) # arg 4
jal remquo
addu $sp, $sp, 16
# Print out c and d.
li $v0, 1
lw $a0, -8($fp) # c
syscall
li $v0, 11 # print char
li $a0, ' '
syscall
li $v0, 1
lw $a0, -4($fp) # d
syscall
li $v0, 10 # exit
syscall
remquo: subu $sp, $sp, 8
sw $ra, 4($sp)
sw $fp, 0($sp)
subu $sp, $sp, 4
# num / den
lw $t0, 8($fp) # num
lw $t1, 12($fp) # den
div $t0, $t0, $t1
# *quoPtr = ...
lw $t1, 16($fp) # quoPtr
sw $t0, 0($t1) # *quoPtr
# num % den
lw $t0, 8($fp) # num
lw $t1, 12($fp) # den
rem $t0, $t0, $t1
# *remPtr = ...
lw $t1, 20($fp) # remPtr
sw $t0, 0($t1) # *remPtr
lw $sp, 0($sp)
lw $ra, 4($sp)
addu $sp, $sp, 8
jr $ra
|
struct Host {
char name[20];
int ip[4];
} mycomputer = {
"snafu.org",
{ 101, 58, 278, 3 }
};
int printIP(const
struct Host machine)
{
int i;
for (i = 0; i < 4; i++)
printf("%d ",
machine.ip[i]);
}
int main()
{
printIP(mycomputer);
}
|
.data
mycomputer:
.asciiz "snafu.org"
.space 10
.word 101, 58, 278, 3
.text
printIP:
subu $sp, $sp, 8
sw $fp, 4($sp)
sw $ra, 0($sp)
move $fp, $sp
subu $sp, $sp, 4
sw $zero, -4($fp) # i
loop: lw $t2, -4($fp) # i
bge $t2, 4, end
li $v0, 1
la $t0, 28($fp) # ip
lw $t2, -4($fp) # i
sll $t1, $t2, 2
add $t0, $t0, $t1
lw $a0, 0($t0)
syscall
li $v0, 11 # print char
li $a0, ' '
syscall
lw $t0, -4($fp) # i
add $t0, $t0, 1
sw $t0, -4($fp) # i
j loop
end: addu $sp, $sp, 4
lw $ra, 4($sp)
lw $fp, 0($sp)
addu $sp, $sp, 8
jr $ra
main: move $fp, $sp
# Copy whole struct!
# 20*1 + 4*4 = 32 bytes
subu $sp, $sp, 32
lw $t0, mycomputer+0
sw $t0, 0($sp)
lw $t0, mycomputer+4
sw $t0, 4($sp)
lw $t0, mycomputer+8
sw $t0, 8($sp)
lw $t0, mycomputer+12
sw $t0, 12($sp)
lw $t0, mycomputer+16
sw $t0, 16($sp)
lw $t0, mycomputer+20
sw $t0, 20($sp)
lw $t0, mycomputer+24
sw $t0, 24($sp)
lw $t0, mycomputer+28
sw $t0, 28($sp)
jal printIP
addi $sp, $sp, 32
li $v0, 10
syscall
|
struct Host {
char name[20];
int ip[4];
} mycomputer = {
"snafu.org",
{ 101, 58, 278, 3 }
};
int printIP(const
struct Host *machine)
{
int i;
for (i = 0; i < 4; i++)
printf("%d ",
machine->ip[i]);
}
int main()
{
printIP(&mycomputer);
}
|
.data
mycomputer:
.asciiz "snafu.org"
.space 10
.word 101, 58, 278, 3
.text
printIP:
subu $sp, $sp, 8
sw $fp, 4($sp)
sw $ra, 0($sp)
move $fp, $sp
subu $sp, $sp, 4
sw $zero, -4($fp) # i
loop: lw $t2, -4($fp) # i
bge $t2, 4, end
li $v0, 1
lw $t0, 8($fp) # machine
lw $t2, -4($fp) # i
sll $t1, $t2, 2
add $t0, $t0, $t1
lw $a0, 20($t0) # ip
syscall
li $v0, 11 # print char
li $a0, ' '
syscall
lw $t0, -4($fp) # i
add $t0, $t0, 1
sw $t0, -4($fp) # i
j loop
end: addu $sp, $sp, 4
lw $ra, 4($sp)
lw $fp, 0($sp)
addu $sp, $sp, 8
jr $ra
main: move $fp, $sp
# Pass param as address.
# 1 * 4 = 4 bytes
subu $sp, $sp, 4
la $t0, mycomputer
sw $t0, 0($sp)
jal printIP
addi $sp, $sp, 4
li $v0, 10
syscall
|
Last modified 2002-12-05