Section 14.6 Division
Algorithm 2.5.1 shows how we can compute the decimal equivalent of an int
stored in binary format. It repeatedly divides the int
by \(10\text{.}\) The remainder after each integer division is the equivalent decimal digit, starting with the loworder digits.
Many programming languages use “modulo” (‘%
’ in C) and “remainder” interchangeably. The definitions of “modulo” vary in the literature. The differences arise when dealing with negative numbers. Our use here will not use negative numbers, so it will not be an issue.
There are two simple divide instructions, sdiv
and udiv
.
SDIV

Divides a signed 32bit value into another signed 32bit value, producing a 32bit signed result.
SDIV{<c>} <Rd>, <Rn>, <Rm>
The condition flags are not changed.
<c>
is the condition code, Table 9.2.1.<Rd>
specifies the destination register.<Rm>
contains the divisor and<Rn>
the dividend.
The value in
<Rn>
is divided by the value in<Rm>
and the result is stored in<Rd>
. All values are treated as signed values. The remainder is lost. UDIV

Divides an unsigned 32bit value into another unsigned 32bit value, producing a 32bit unsigned result.
UDIV{<c>} <Rd>, <Rn>, <Rm>
The condition flags are not changed.
<c>
is the condition code, Table 9.2.1.<Rd>
specifies the destination register.<Rm>
contains the divisor and<Rn>
the dividend.
The value in
<Rn>
is divided by the value in<Rm>
and the result is stored in<Rd>
. All values are treated as unsigned values. The remainder is lost.
Since the divide instructions in the ARM ignore the remainder, we will need to compute it on our own in order to use Algorithm 2.5.1. The sequence of instructions:
udiv r0, r6, r7 @ no, div to get quotient mul r1, r0, r7 @ need for computing remainder sub r2, r6, r1 @ the mod (remainder)
uses the udiv
instruction to compute the quotient. The quotient is then multiplied by the divisor. Subtracting this result from the original dividend yields the remainder. Listing 14.6.1 shows how this can be done.
This algorithm produces the decimal numeral characters starting with the loworder digits. So the function stores the characters backwards
in a local char
array. It then copies the characters to the address passed by the calling function, thus reversing the string.
As discussed in the Preface, we consider only a small subset of the ARM instruction set architecture in this book. But there are many instructions that can be very useful for improving the efficiency of some computations. One such instruction is mls
which performs the multiply and subtract in one operation, thus simplifying the computation of the remainder.
MLS

Multiplies two 32bit values in registers, subtracts the result from the value in a third register, and stores that in a fourth register.
MLS{<c>} <Rd>, <Rn>, <Rm>, <Ra>
The condition flags are not changed.
<c>
is the condition code, Table 9.2.1.<Rd>
specifies the destination register.<Rm>
and<Rn>
contain the multiplier and multiplicand.<Ra>
contains the minuend.
The values in
<Rm>
and<Rn>
are multiplied, the result is subtracted from the value in<Ra>
, and the result is stored in<Rd>
. Only the loworder 32 bits are retained.