Converting this C Code to Assembly to do Division shifting one bit at a time

I'm trying to convert this C Code to Assembly to do division without using the division sign. The C Code has been proven to work. I've finished converting the C Code to Assembly to the best of my ability. It will work correctly when dividing by 1 or when 0 is in the numerator, but will not work for division such as 5789217 / 8, 10 / 5, etc. The output for these is always that the quotient is 0 and the remainder is 0.

I tried making some minor tweaks here and there but ultimately im not sure where the assembly code is going wrong.

Here's the C Code:

#include <stdio.h>
#include <stdlib.h>
 
int main (int argc, char *argv[]){
 
    //first command line argument is the dividend
    long long dividend = atoll(argv[1]);
    //second command line argument is the divisor
    long long divisor = atoll(argv[2]);
    //we need the remainder 
    long long remainder = 0;
    //we need the quotient
    long long quotient = 0;

    if (divisor == 1) {
        quotient = dividend;
        remainder = 0;
    } else {
        //runs for 31 iterations as stated in the prompt 
        for(int i = 31; i >= 0; i--){
            remainder <<= 1;
            remainder |= (dividend >> i) & 1;
            if (remainder >= divisor){
                remainder -= divisor;
                quotient |= 1 << i;
            }
        }
    }
 
    //print the results
    printf("%lld / %lld = %lld R %lld\n", dividend, divisor, quotient, remainder);
 
    return 0; 
}

Here is the UPDATED Assembly code:

.global _start

.data
dividend:
    .long 100
divisor:
    .long 100
quotient:
    .long 0
remainder:
    .long 0

.text
_start:
    movl quotient, %eax
    movl remainder, %edx
    movl divisor, %esi # previously ecx
    movl dividend, %ebx
    movl $31, %ecx # previously esi 
    # first if statement that checks if the divisor is 1
    cmpl $1, %esi
    jne for_start

    # divisor is 1, so quotient is dividend and remainder is 0
    movl %ebx, %eax
    xor %edx, %edx
    jmp done

for_start:
    cmpl $0, %ecx
    jle done

    # INSIDE FOR LOOP:

    shll $1, %edx        # shift remainder left
    movl %ebx, %edi      # copy dividend
    shrl %cl, %edi        # shift copy right
    and $1, %edi         # and 1 with the remainder
    orl %edi, %edx       # or the remainder and quotient CHECK THIS
    # start of if statement

    cmpl %esi, %edx       # compare the remainder and the divisor
    jle next_iter         # if remainder is less than divisor, skip subtraction

    sub %esi, %edx        # subtract divisor from remainder 
    movl $1, %edi
    shll %cl, %edi      # Shift quotient left by cl
    orl %edi, %eax     # Or quotient with 1

next_iter:
    decl %ecx             # decrement loop counter
    jns for_start

    # END OF FOR LOOP

done:

    nop

Example assembly code is in <A HREF="https://gist.github.com/joshudson/88570993c7863e4ba83af5fef61af2ad">this github gist</A>. (I had written it some months ago. Time to publish.) I'm certain if somebody stares at my algorithm long enough they'll find a way to tear it to shreds. I finally got one working on my own though.

Your algorithm is completely differently though.

The problem with your asm translation of your alrogithm is here:

    shll $1, %edx        # shift remainder left
    shrl $1, %ebx        # shift dividend right
    and $1, %edx         # and 1 with the remainder

After the first loop, %edx is either 0 or 1. After the second loop it must be 0.

It's like it wants to read

    shll $1, %edx        # shift remainder left
    movl %ebx, %edi      # copy dividend
    shrl %esi, %edi        # shift copy right
    and $1, %edi         # and 1 with the remainder

but that doesn't work because that shift instruction doesn't exist. Redo register allocation so that i is in %cl instead. (Put the divisor in %esi or something like that.)

    shll $1, %edx        # shift remainder left
    movl %ebx, %edi      # copy dividend
    shrl %cl, %edi        # shift copy right
    and $1, %edi         # and 1 with the remainder