Bitwise IO/MIPS Assembly
<lang mips> .data
- the following are used by the subroutines
bitbuf: .byte 0, 0 cumulus: .word 0 rbitbuf: .byte 0, 0 rfree: .word 0
- these are instead for testing
outbuf: .space 16 abuf: .space 16
txt: .asciiz "This is a test"
.text
main:
# ---- encode txt to buf ----- la $s0, txt la $s1, outbuf
encloop:
lbu $a0, ($s0) beq $a0, $0, txtend li $a1, 7 move $a2, $s1 jal bits_write addu $s0, $s0, 1 move $s1, $v1 b encloop
txtend:
move $a1, $s1 jal bits_flush
move $s1, $v0 # update buf, will be used as "terminator" la $s0, outbuf
# ---- write buffer
wrtchar:
beq $s0, $s1, wrtend # while $s0 < $s1 {
lb $a0, ($s0)
li $v0, 11
syscall # print_char($a0)
addi $s0, $s0, 1 # inc $s0
b wrtchar # }
wrtend:
# ---- decode from buffer in bufferb---- # $s1 is still our end marker la $s3, outbuf # prev. output becomes input li $s7, 7 # commodity la $s4, abuf # current output buf
decloop:
bge $s3, $s1, decend # while $s3(input) < $s1(limit) move $a0, $0 # clean acc. move $a1, $s7 # 7 bits move $a2, $s3 # from input buf jal bits_read # read 7 bits into acc. move $s3, $v0 # update input buf sb $v1, ($s4) addi $s4, $s4, 1 # write char and update outp buf ptr b decloop # end while
decend:
# lets output abuf; $s4 points to end of abuf, # we need to mark it with 0 to print it as a str sb $0, ($s4) la $a0, abuf li $v0, 4 syscall # print_string(abuf)
li $v0, 10 # exit syscall
- read_bits
- $a0 acc.
- $a1 how many (max 32)
- $a2 input buffer
- > $v1 (new acc)
- > $t0 num of read bits or less (failure)
- > $v0 updated input buffer
bits_read:
sub $sp, $sp, 20 # local vars sw $ra, 0($sp) # save regs sw $s0, 4($sp) sw $s1, 8($sp) sw $s2, 12($sp) sw $s3, 16($sp)
move $s3, $a2 # $s3 input buf move $s0, $a0 # $s0 acc move $s1, $a1 # $s1 n move $s2, $0 # rbit = 0 li $t0, 32 bgt $a1, $t0, brexit # if n > 32 then return
brloop:
ble $s1, $0, brexit # while n > 0 (if <= 0 break) move $a0, $s0 move $a1, $s3 jal read_bit # read 1 bit into acc. move $s3, $v0 # update input buf li $t1, 1 bne $t0, $t1, brexit # exit if not read move $s0, $v1 # get updated acc sub $s1, $s1, 1 # n-- addi $s2, $s2, 1 # rbit++ b brloop
brexit:
move $t0, $s2 # currently read bits move $v1, $s0 # new accumulator move $v0, $s3 # updated input ptr lw $ra, 0($sp) # restore regs lw $s0, 4($sp) lw $s1, 8($sp) lw $s2, 12($sp) lw $s3, 16($sp) addu $sp, $sp, 20 # and free stack jr $ra # return
- get last (maybe incomplete) accumulated byte
- $a0 accumulator
- >$v0 free storage
bits_getlast:
lw $t0, rfree li $t1, 8 sub $t1, $t1, $t0 # sochar - rfree sllv $a0, $a0, $t1 # *d << (8 - rfree) lbu $t2, rbitbuf srlv $t2, $t2, $t0 # rbitbuf >> rfree sb $0, rbitbuf # rbitbuf = 0 sw $0, rfree # rfree = 0 move $v0, $t1 jr $ra # return sochar - rfree
- read a single bit
- $a0 accumulator
- $a1 input buffer
- > $v1 new accumulator
- > $t0 bit read (1 or not 1; in this impl, reading
- can't fail unless input buffer is an invalid ptr
- > $v0 updated input buffer
read_bit:
sub $sp, $sp, 20 # local stack, sw $s0, 0($sp) # save regs sw $s1, 4($sp) sw $s2, 8($sp) sw $s3, 16($sp)
move $s0, $a0 # save args move $s3, $a1 # $s0 = acc, $s3 = inbuf
lw $s1, rfree # preload rfree and lbu $s2, rbitbuf # rbitbuf
bne $s1, $0, skipif # if rfree == 0 then
lbu $s2, ($s3) # rbitbuf = nextchar() addi $s3, $s3, 1 # update it inp buf
li $s1, 8 # rfree = 8
skipif:
sll $s0, $s0, 1 # *d << 1 srl $t0, $s2, 7 # rbitbuf >> (8-1) andi $t0, $t0, 1 # & 1 or $s0, $s0, $t0 # | *d sll $s2, $s2, 1 # rbitbuf << 1 sub $s1, $s1, 1 # rfree--
sw $s1, rfree sb $s2, rbitbuf # update rfree, rbitbuf li $t0, 1 # $t0 returns 1
move $v1, $s0 # return the acc. in $v1 move $v0, $s3 # and updated inp buf in $v0 lw $s0, 0($sp) # restore regs lw $s1, 4($sp) lw $s2, 8($sp) lw $s3, 16($sp) add $sp, $sp, 20 # .. and stack jr $ra # return($v0, $v1)
- bits_write; write upto 32 bits
- $a0 holds the bits (right aligned)
- $a1 how many bits are significative
- $a2 dest buf
- > $v1 updated buf ptr
- > $v0 written bits (-1 on error)
bits_write:
sub $sp, $sp, 28 # some local storage sw $fp, 20($sp) move $fp, $sp sw $s1, 4($fp) # save regs and values sw $s0, 0($fp) sw $s2, 8($fp) sw $s3, 12($fp) sw $ra, 16($fp) sw $s4, 24($fp)
move $s4, $a2
move $s1, $a1 # n is $s1 li $t0, 32 bgt $a1, $t0, error # n > 32 => return(-1) sub $t0, $t0, $a1 # 32 - n sllv $s0, $a0, $t0 # d << (32-n) move $s3, $0
loop:
blez $s1, exit0 # if n <= 0 then break sub $s1, $s1, 1 # n-- addu $s3, $s3, 1 # wbit++ move $a0, $s0 rol $a0, $a0, 1 # place "last" bit in first pos. move $a1, $s4 jal appendbit # append it sll $s0, $s0, 1 # dpad << 1 move $s4, $v1 # update buf ptr b loop # loop
error:
li $v0, -1 b exit
exit0:
move $v0, $s3
exit:
lw $s1, 4($fp) # restore regs
lw $s0, 0($fp)
lw $s2, 8($fp)
lw $s3, 12($fp)
move $v1, $s4
lw $s4, 24($fp)
lw $ra, 16($fp)
move $sp, $fp # and release stack
lw $fp, 20($sp)
addi $sp, $sp, 28
jr $ra # return wbit, ptr to byte beyond last
# written
- flush bits
- $a1 output buf
- >$v0 adv. ptr to buf.
bits_flush:
li $t0, 8 lw $t1, cumulus sub $t0, $t0, $t1 # 8 - cumulus lbu $a0, bitbuf sllv $a0, $a0, $t0 # bitbuf <<= (8 - cumulus) sb $a0, ($a1) # write to buf addi $v0, $a1, 1 # inc buf ptr sb $0, bitbuf # bitbuf := 0 sw $0, cumulus # cumulus := 0 jr $ra
- add a single bit.
- $a0 holds the bit (as LSB i.e. "rightmost bit")
- $a1 output buf
- > $v0 number of written bits (always 1)
- > $v1 incremented buf ptr
appendbit:
sub $sp, $sp, 16 # save s-regs on stack sw $s0, 0($sp) sw $s1, 4($sp) sw $s2, 8($sp) sw $s3, 12($sp)
move $s3, $a1 # save buf ptr
move $s0, $a0 # copy argument lw $s1, cumulus # get cumulus lbu $s2, bitbuf # preload bitbuf li $t1, 8 bne $s1, $t1, mroom # if cumulus = 8 then sb $s2, ($s3) # write bitbuf to buf add $s3, $s3, 1 # inc buf. move $s2, $0 # bitbuf := 0 move $s1, $0 # cumulus := 0
mroom: # endif
sll $s2, $s2, 1 # bitbuf <<= 1 andi $s0, $s0, 1 # arg & 1 or $s2, $s2, $s0 # bitbuf |= arg sb $s2, bitbuf # store bitbuf addi $s1, $s1, 1 # cumulus++ sw $s1, cumulus # store cumulus
lw $s0, 0($sp) # restore regs lw $s1, 4($sp) lw $s2, 8($sp) move $v1, $s3 lw $s3, 12($sp) addi $sp, $sp, 16 # restore stack li $v0, 1 jr $ra # return(1)</lang>