restoring Division in MIPS Assembly

Question

I am trying to write a program in MIPS assembly language that implements the restoring division algorithm.

I found very good example of my task that I have to do, the thread is old and closed, and I don't fully understand it.

http://forums.extremeoverclocking.com/showthread.php?p=2693342

I have few questions:

so in the end how should look like good code? Beacuse i understand that the code in 1st post is wrong ?
What is good algorithm of restoring Division?

" You are dividing two numbers: a/b = c, remainder = d

Register A = a Register B = b Register P = a "connected" set of two registers (64 bit register)
1. Shift the double regiaster (P,A) one bit left
  - use zero sign extension for unsigned values
  - force MSB(P) to fall off the upper end
2. Subtract b from P
3. If the result is < 0 LSB(A) = 0 else LSB(A) = 1
4. If result is negative P = P + b
Repeat n times (for n-bit values) Contents of register A = a/b Contents of register P = remainder(a/b)"

is this good algorithm? can someone write it in much simplier english? Cause i don;t understand it.

addition:

code from 1-st post:

.data
    GETA:           .asciiz "Enter A "
    GETB:           .asciiz "Enter B "
    QMSG:           .asciiz "Q = "
    RMSG:           .asciiz "R = "
    NL:             .asciiz "
"
    ERR:            .asciiz "Divide by zero error
"
    left:           .word 1
    right:          .word 1
.text
.globl main
main:
    # Prompt for an integer A: divisor
    li $v0, 4                            
    la $a0, GETA                           
    syscall                                     
    # Read A from user
    li $v0, 5                              
    syscall                              

    move $t0, $v0                         
    # Prompt for an integer B: dividend
    li $v0, 4                             
    la $a0, GETB                         
    syscall     

    # Read B from user
    li $v0, 5                               
    syscall                               
    move $a1, $v0                          

# Initialize quotient register to zero
# Initialize left half of Divisor regisiter with divisor
# Initialize remainder register with the dividend (right aligned)
# 1. Remainder = Remainder - Divisor
#    Remainder >= 0 goto Step 2a.
#    Remainder < 0 goto Step 2b.
# 2a. Shift quotient register to the left, setting rightmost bit to 1
# 2b. Restore the original value bu Remainder = Remainder + Divisor
#     Shift quotient register to the left setting new LSB to zero
# 3. Shift divisor register to the right 1 bit
# < 33 repitions, goto step 1
# >= 33 repititions, print result 
#
# Register usage:
# $a0 = divisor
# $a1 = dividend
# $a2 = quotient
# $a3 = remainder
# $t4 = counter of 33 repetitions
# $t0 = divisor (temp)
initialize:
    li $a2, 0                               # $a2 = quotient = 0
    swl $t0, left
    lwl $a0, left                           # $a0 = left half of divisor
    swr $a1, right
    lwr $a3, right                          # $a3 = remainder = $a2
    li $t4, 33                              # $t4 = counter = 33

step_one:
    sub $a3, $a3, $a0
    bge $a3, $zero, step_two_a
    blt $a3, $zero, step_two_b

step_two_a:
    #slt $a2, $zero, $a2
    sll $a2, $a2, 1
    ori $a2, $a2, 1
    j step_three

step_two_b:

    add $a3, $a3, $a0
    sll $a2, $a2, 1

step_three:

    sra $a0, $a0, 1

step_four:

    addi $t4, $t4, -1
    bge $t4, $zero, step_one
    beq $t4, $zero, print_result

print_result:

    li $v0, 4                  
    la $a0, QMSG                     
    syscall                   

    move $a0, $a2                      
    li $v0, 1                         
    syscall                            

    li $v0, 4                          
    la $a0, NL                         
    syscall                           

    li $v0, 4                    
    la $a0, RMSG                     
    syscall                     

    move $a0, $a3                      
    li $v0, 1                          
    syscall                            

    li $v0, 4                          
    la $a0, NL                         
    syscall

    j exit_program                    

exit_program:
    li $v0, 10                       
    syscall

probably missing something like

Code:

 # shift the double register (P,A) one bit left
    slt $t2, $v0, $zero                  # store MSB of hi
    sll $v0, $v0, 1                      # shift hi left 1 bit
    slt $t3, $v1, $zero                  # store MSB of lo
    or $v0, $v0, $t2                     # move MSB of lo into LSB of hi
    sll $v1, $v1, 1                      # shift lo left 1 bit

how should like fine code??

restoring Division in MIPS Assembly

Answers (1)

Related Questions