Code Examples
SAL Examples
ASCII To Integer
## Convert text into number
## Ben Kuehmichel
#### Input Integer Number as ASCII ####
## Reads until digit isn't numeric
## The not numeric character sits
## in the INT_char variable
## The number sits in the INT_nu variable
## Return address must be placed in INT_return
.data
INT_char: .byte
INT_num: .word 0
INT_tmp: .word 0
INT_return: .word
# ASCII 0 is number 48
# ASCII 9 is number 57
.text
ASCII2INT:
get INT_char #read a char
INT_lp: blt INT_char, 48, INT_ret #if INT_char < 48 end
bgt INT_char, 57, INT_ret #if INT_char > 57 end
mul INT_num, INT_num, 10 #mul by 10 for positional power
sub INT_tmp, INT_char, 48 #convert ASCII value to number
add INT_num, INT_num, INT_tmp # sum into variable
get INT_char
b INT_lp
INT_ret:
b (INT_return)
#### End of ASCII to Integer Procedure ####
.data
str1: .asciiz "Enter a number: "
str2: .asciiz "Number is "
nl: .byte '\n'
.text
__start:
puts str1
la INT_return, show
b ASCII2INT
show: put nl
puts str2
put INT_num
put nl
done
Interative Power Function
#### Power Function ####
## Place the base in POW_base
## Place the exponent in POW_exp
## Result is in POW_result
## Store return address in POW_return
.data
POW_base: .word
POW_exp: .word
POW_result: .word
POW_return: .word
.text
POWER:
# if (exp <=0) result=1
move POW_result,1
blez POW_exp, POW_end
move POW_result, POW_base
POW_lp: ble POW_exp, 1,POW_end
mul POW_result, POW_result, POW_base
sub POW_exp, POW_exp, 1
b POW_lp
POW_end:
b (POW_return)
#### End Power Function ####
.data
str1: .asciiz "Enter base: "
str2: .asciiz "Enter exponent: "
str3: .asciiz " to the power "
str4: .asciiz " is "
nl: .byte '\n'
.text
__start:
start:
puts str1
get POW_base
put nl
puts str2
get POW_exp
put nl
put POW_base
puts str3
put POW_exp
puts str4
la POW_return, finish
j POWER
finish:
put POW_result
put nl
done
Number Conversion
top
MAL Examples
top
MAL basic integer input procedure
## By Ben Kuehmichel
#### Input Number procedure ####
## number is stored in $v1
## last char read is in $v0
.text
INN:
li $t0, 48
li $t2, 10
move $t1, $0
INN_lp:
getc $t3
beq $t3, $t2, INN_end
sub $t3, $t3, $t0
bltz $t3, INN_end1
bge $t3, $t2, INN_end1
mul $t1, $t1, $t2
add $t1, $t1, $t3
b INN_lp
INN_end1:
add $t3, 48
INN_end:move $v0, $t3
move $v1, $t1
jr $ra
### End of Input Number procedure
MAL basic integer out procedure
#########################################
## By Ben Kuehmichel
#### Output number procedure #####
### Outputs 6 digits of number
## number to output is stored in $a0
.data
flip: .byte 0:7
.text
OUT: ## First we zero the stack
li $t2, 48
la $t0, flip
move $t1, $t0
add $t1, 6
OUT_zero:
sb $t2, ($t0)
add $t0, 1
blt $t0, $t1, OUT_zero
move $t2, $a0
la $t0, flip
# Now we conver the number into
# a bunch of ascii
OUT_lp1:rem $t3, $t2, 10
div $t2, $t2, 10
add $t3, 48
sb $t3, ($t0)
add $t0, 1
bgtz $t2, OUT_lp1
OUT_print: # Now we print out the whole 6 ascii digits
la $t1, flip
OUT_lp2:sub $t0, 1
lbu $t2, ($t0)
putc $t2
bgt $t0, $t1, OUT_lp2
jr $ra
#########################################
TAL Examples
top
TAL Hello World Program
.data
str: .asciiz "Hello World\n"
.text
main: la $a0, str
addi $v0, $0, 4
syscall
jr $ra
TAL Average
.data
prompt: .asciiz "Input: "
avg: .asciiz "Average: "
.text
main:
loop: # Output prompt
la $a0, prompt
addi $v0, $0, 4
syscall
#input value
addi $v0, $0, 5
syscall
bltz $v0, end_loop
#add to total
add $t0, $t0, $v0
addi $t1, $t1, 1
b loop
end_loop:
# Display Average
la $a0, avg
addi $v0, $0, 4
syscall
# compute average
div $t0, $t1
mflo $a0
addi $v0, $0, 1
syscall
addi $a0, $0, '\n'
addi $v0, $0, 11
syscall
end_main:
jr $ra
Recursive Factorial
.data
inp: .asciiz "Input: "
val: .asciiz "Value: "
.text
main:
#backup return address
sw $ra, ($sp)
addi $sp, $sp, -4
# get input
la $a0, inp
addi $v0, $0, 4
syscall
addi $v0, $0, 5
syscall
add $a0, $v0, $0
# call FACT procedure
jal facts
# print output
add $t0, $v0, $0
la $a0, val
addi $v0, $0, 4
syscall
add $a0, $t0, $0
addi $v0, $0, 1
syscall
addi $a0, $0, '\n'
addi $v0, $0, 11
syscall
end_main:
addi $sp, $sp, 4
lw $ra, ($sp)
jr $ra
########################################
########### Factorial Procedure #######
# $a0 - contains number to compute on
# $v0 - containst result
.text
facts:
sw $ra, ($sp)
addi $sp, $sp, -4
sw $a0, ($sp)
addi $sp, $sp, -4
# test for base case
beqz $a0, FACT_b
#make recursive call
addi $a0, $a0, -1
jal facts
# compute current result
addi $sp, $sp, 4
lw $t0, ($sp)
mult $v0, $t0
mflo $v0
b FACT_ret
FACT_b:
addi $v0, $0, 1
addi $sp, $sp, 4
FACT_ret:
addi $sp, $sp, 4
lw $ra, ($sp)
jr $ra
#########################################
Exception Handling
top
Simple Exception Handler
# Written by Ben Kuehmichel
# University of Wisconsin - Milwaukee
# April 17, 2005
.kdata
_k_v0: .word 0
_k_v1: .word 0
_k_a0: .word 0
_k_a1: .word 0
_k_t0: .word 0
_k_t1: .word 0
_k_t2: .word 0
_k_t3: .word 0
_k_t4: .word 0
_k_ra: .word 0
_k_msg: .asciiz "Kernel Mode!\n"
.ktext 0x80000180
# backup everthing
_k_backup:
la $k0, _k_v0
sw $v0, ($k0)
sw $v1, 4($k0)
sw $a0, 8($k0)
sw $a1, 12($k0)
sw $t0, 16($k0)
sw $t1, 20($k0)
sw $t2, 24($k0)
sw $t3, 28($k0)
sw $t4, 32($k0)
sw $ra, 36($sp)
la $a0, _k_msg
li $v0, 4
syscall
mfc0 $t0, $13 # get cause register
srl $t0, $t0, 2
andi $t0, $t0, 0xf
bnez $t0, _k_exception
b _k_interrupt
_k_exception:
beq $t0, 13, _k_trap_go
b _k_exception_return
_k_trap_go:
mfc0 $t4, $14
addiu $t4, $t4, 4
mtc0 $t4, $14
jal _k_trap
_k_exception_return:
b _k_exit
_k_interrupt:
b _k_exit
# restore everything
_k_restore:
la $k0, _k_v0
lw $v0, ($k0)
lw $v1, 4($k0)
lw $a0, 8($k0)
lw $a1, 12($k0)
lw $t0, 16($k0)
lw $t1, 20($k0)
lw $t2, 24($k0)
lw $t3, 28($k0)
lw $t4, 32($k0)
lw $ra, 36($sp)
eret
_k_exit:
mfc0 $t4 $12 # Enable interrupts and mask in Status reg
ori $t4 $t4 0xff01
mtc0 $t4 $12
mfc0 $t4 $13
and $t4 0xffff00ff # Clear IP bits in Cause register
mtc0 $t4 $13
b _k_restore
_k_trap:
## We will treat this like a syscall
## so we want to use the syscall codes
## and do what we need to
la $k0, _k_v0
lw $v0, ($k0)
lw $a0, 8($k0)
syscall
sw $v0, ($k0)
jr $ra
.text
.globl __start
__start:
jal main
nop
li $v0, 10
syscall
A Little File which uses this Exception Handler
.text
main: ori $v0, 1
addi $a0, $0, 10
teq $0, $0
jr $ra