div - unsigned divide

rax = rdx:rax / source
rdx = rdx:rax % source or
eax = edx:eax / source
edx = edx:eax % source or
ax = dx:ax / source
dx = dx:ax % source or
al = ax / source
ah = ax % source

The div instruction for 64, 32 and 16 bit divisor sizes uses a pair of registers for the dividend (number to be divided). For 8 bit divides the dividend is stored in ax. For the larger sizes the low half of the dividend is stored in rax, eax, or ax and the larger half is stored in rdx, edx or dx. div produces 2 results: the quotient and remainder. For 64, 32 and 16 bit sizes the quotient is stored in rax, eax or ax while the remainder is stored in rdx, edx or dx. For 8 bit divides the quotient is stored in al and the remainder is stored in ah. The single operand is the divisor and can be either a register or a memory address.

div can result in a division exception (divide by 0).

The div instruction is relatively slow - perhaps 25 to 50 times as slow as an add instruction. The 64 bit divide is the worst and the other sizes are roughly the same speed. So when speed is critical try to avoid using div and, if you must use div, try to use the 32 bit version rather than the 64 bit version.

        xor     edx, edx        ; prepare to divide with the dividend in rax
        div     r9              ; divide rdx:rax by r9
        xor     edx, edx
        div     dword 10        ; divide edx:eax by 10
        xor     edx, edx
        div     dword [x]       ; divide edx:eax by 32 bit variable x
        shr     rax, 4          ; shift right 4 (quick divide by 16)

flags: OF SF ZF AF CF PF: all undefined