In: Computer Science
What is the proper way to define an assembly code in in-line assembler x86 for this case:
multiplication without using mul/imul, using hexadecimal numbers for "shl" instruction.
If we take a look at the timing for the multiply instruction, we
will notice that the execution time for this instruction is rather
long. Only the div and idiv instructions take longer on the 8086.
When multiplying by a constant, we can avoid the performance
penalty of the mul and imul instructions by using shifts,
additions, and subtractions to perform the multiplication.
A shl operation performs the same operation as multiplying the
specified operand by two. Shifting to the left two bit positions
multiplies the operand by four. Shifting to the left three bit
positions multiplies the operand by eight. In general, shifting an
operand to the left n bits multiplies it by 2n. Any value can be
multiplied by some constant using a series of shifts and adds or
shifts and subtractions. For example, to multiply the ax register
by ten, you need only multiply it by eight and then add in two
times the original value. That is, 10*ax = 8*ax + 2*ax. The code to
accomplish this is
shl ax, 1 ;Multiply AX by two
mov bx, ax ;Save 2*AX for later
shl ax, 1 ;Multiply AX by four
shl ax, 1 ;Multiply AX by eight
add ax, bx ;Add in 2*AX to get 10*AX
The ax register (or just about any register, for that matter) can be multiplied by most constant values much faster using shl than by using the mul instruction. This may seem hard to believe since it only takes two instructions to compute this product:
mov bx, 10
mul bx
However, if we look at the timings, the shift and add example
above requires fewer clock cycles on most processors in the 80x86
family than the mul instruction. Of course, the code is somewhat
larger (by a few bytes), but the performance improvement is usually
worth it. Of course, on the later 80x86 processors, the mul
instruction is quite a bit faster than the earlier processors, but
the shift and add scheme is generally faster on these processors as
well.
We can also use subtraction with shifts to perform a multiplication
operation. Consider the following multiplication by seven:
mov bx, ax ;Save AX*1
shl ax, 1 ;AX := AX*2
shl ax, 1 ;AX := AX*4
shl ax, 1 ;AX := AX*8
sub ax, bx ;AX := AX*7
This follows directly from the fact that ax*7 = (ax*8)-ax
Thank you.