Category : Assembly Language Source Code
Archive   : ASMTUT2.ZIP
Filename : CHAP8.DOC

Output of file : CHAP8.DOC contained in archive : ASMTUT2.ZIP



There are seven instructions that move the individual bits of a
byte or word either left or right. Each instruction works
slightly differently. We'll make a standard program and then
substitute each instruction into that program.


The instructions SHL (shift logical left) and SAL (shift
arithmetic left) are exactly the same. They have the same machine
code. They shift each bit to the left. How far? That depends.
There are two (and only two) forms of this instruction. All other
shift and rotate instructions have these two (and only these two)
forms as well. The first form is:

shl al, 1

Which shifts each bit to the left one bit. The number MUST be 1.
No other number is possible. The other form is:

shl al, cl

shifts the bits in AL to the left by the number in CL. If CL = 3,
it shifts left by 3. If CL = 7, it shifts left by 7. The count
register MUST be CL (not CX). The bits on the left are shifted
out of the register into the bit bucket, and zeros are inserted
on the right. The easy way to understand this is to fire up the
standard program. Remember, from now on we always use

; + + + + + + + + + + + + + + + START CODE BELOW THIS LINE
mov ax_byte, 0A3h ; half reg, low reg binary
mov bx_byte, 0A4h ; half reg, low reg hex
mov cx_byte, 0A1h ; half reg, low reg signed
mov dx_byte, 0A2h ; half reg, low reg unsigned
lea ax, ax_byte
call set_reg_style

mov ax, 0 ; clear registers
mov bx, 0
mov cx, 0
mov dx, 0
mov di, 0
mov bp, 0
call show_regs

call get_hex_byte ; get number and put in registers
mov bl, al
mov cl, al


The PC Assembler Tutor - Copyright (C) 1989 Chuck Nelson

Chapter 8 - Shift and Rotate 57

mov dl, al
mov si, 8 ; 8 iterations of the loop
and al, al ; set the flags
call show_regs_and_wait
sal al, 1
sal bl, 1
sal cl, 1
sal dl, 1
call show_regs_and_wait
dec si
jnz shift_loop
jmp outer_loop

; + + + + + + + + + + + + + + + END CODE ABOVE THIS LINE

This standard program is with bytes, not words. This is because
if we had used words we would have performed 16 individual shifts
and that would have been time consuming and boring. First we set
the style to half registers. Notice that one is binary, one is
hex, one is signed and one is unsigned. That covers all bases.
All the registers are then cleared. It would be nice to use the
loop instruction, but CX is committed, so we make our own loop
instruction. We move 8 into SI. The loop instructions are:

dec si
jnz shift_loop

DEC decrements a register or a variable by 1. Its counterpart INC
increments a register or variable by 1. JNZ (jump if not zero)
jumps to 'shift_loop' if SI is not zero.

We get a hex byte in AL and put the same byte in BL, CL, and DL.
This way we will be able to see what is happening in binary, hex,
signed and unsigned. Before starting, we have:

and al, al

This is there to set the flags correctly before starting. All
four are shifted left one bit each time, and then we look at the

Assemble, link and run it. Enter the number 7. In binary, that is
(0000 0111). Take a look at the flags before starting. It is a
positive number so SF shows '+'. ZF is not set. PF shows 'O'. O
stands for odd. Every time you perform an arithmetic or logical
operation, the 8086 checks parity. Parity is whether the number
contains an even or odd number of 1 bits. This contains 3 1 bits,
so the parity is odd. The possible settings are 'E' for even and
'O' for odd.{1} SAL checks for parity (though some of the other
instructions don't). Now press ENTER. It will shift left 1 and
you will have (0000 1110). What does the unsigned number say now?
14. Press ENTER again. (0001 1100) What does the unsigned number
say? 28. Again (0011 1000) 56. Again (0111 0000) 112. Notice that

1 This is for use by communications programs.

The PC Assembler Tutor 58

the signed number reads +112. Look at the CF and OF. They are
both cleared. Things are going to change now. Press ENTER again.
(1110 0000). SF is now '-'. OF, the overflow flag is set because
you changed the number from positive to negative (from +112 to
-32). What is the unsigned number now? 224. CF is cleared. PF is
'0'. Shift again. (1100 0000) OF is cleared because you didn't
change signs. (Remember, the leftmost bit is the sign bit for a
signed number). PF is now 'E' because you have two 1 bits, and
two is even. CF is set because you shifted a 1 bit off the left
end. Keep pressing ENTER and watch SF, OF, CF, and PF.

Let's look at the unsigned numbers we had until we started
shifting 1 bits off the left end. We started with 7, then had 14,
28, 56, 112, 224. This instruction is multiplying by 2. That's
right, and it is MUCH faster than multiplication (about 50 times
faster). Far and away the fastest way to multiply a register by
2, 4 or 8 is to use sal.

; by 2 ;by 4 ; by 8
sal di,1 sal di, 1 sal di, 1
sal di, 1 sal di, 1
sal di, 1

For a register, it is faster to use a series of 1 shifts than to
load cl. For a variable in memory, anything over 1 shift is
faster if you load cl.

Do a few more numbers to see what is happening both with the
number and the flags. CF always signals when a 1 bit has been
shifted off the end.


Unlike the left shift instruction, there are two completely
different right shift instructions. SHR (shift logical right)
shifts the bits to the right, setting CF if a 1 bit is pushed off
the right end. It puts 0s in the leftmost bit. Make a copy of
SAL.ASM and replace the four instructions:

sal al, 1
sal bl, 1
sal cl, 1
sal dl, 1

with SHR. We'll call the new program SHR.ASM. Run this one too.
Instead of 7, use E0h (1110 0000) which is 224d. The first time
you shift (0111 0000) the OF flag will be set because the sign
changed. Keep shifting, noting the flags and the unsigned number.
This time we have 224, 112, 56, 28, 14, 7, 3, 1. It is dividing
by two and is once again MUCH faster than division. For a single
shift, the remainder is in CF. For a shift of more than one bit,
you lose the remainder, but there is a way around this which we
will discuss in a moment. Do some more numbers till you are
comfortable with the flags and the operation.

If you want to divide by 16, you will shift right four times, so

Chapter 8 - Shift and Rotate 59

you'll lose those 4 bits. But those bits are exactly the value of
the remainder. All we need to do is:

mov dx, ax ; copy of number to dx
and dx, 0000000000001111b ; remainder in dx
mov cl, 4 ; shift right 4 bits
shr ax, cl ; quotient in ax

Using a mask, we keep only the right four bits, which is the


SAR (shift arithmetic right) is different. It shifts right like
SHR, but the leftmost bit always stays the same. This will make
more sense when you run the program. Make another copy, call it
SAR.ASM, and change the four instructions to SAR. The flags
operate the same as for SHR and SHL. The overflow flag will never
change since the left bit will always stay the same.

First enter 74h (+116). We will be looking at the signed numbers
only. Copy down the signed numbers as you go along. They should
be: 116, 58, 29, 14, 7, 3, 1, 0, 0. Now try 8Ch (-116). The
numbers you should get are: -116, -58, -29, -15, -8, -4, -2, -1,
-1. They started out the same, then they got off by one. The
negative numbers are one too negative. Try 39h (+57). The
numbers here are: 57, 28, 14, 7, 3, 1, 0, 0, 0. Just as it should
be for division by 2. Now try C7 (-57). Here the numbers are:
-57, -29, -15, -8, -4, -2, -1, -1, -1. This time it went screwy
right off the bat. Once again, the negative numbers are one too

SAR is an instruction for doing signed division by 2 (sort of).
It is, however, an incomplete instruction. The rule for SAR is:
SAR gives the correct answer if the number is positive. It gives
the correct answer if the number is negative and the remainder is
zero. If the number is negative but there is a remainder, then
the answer is one too negative. The reason for this is a little
complex, but we need to add some code if we want to do signed
division.{2} For SHR, the remainder part was optional. Here it is
not. We need to know whether the remainder is zero or not. For
this example we will do a word shift left by 6. That's dividing
by 64.

remainder_mask dw 002Fh ; 63

call get_signed ; number in ax
mov bx, ax ; copy in bx
and bx, remainder_mask ; the remainder
mov cl,6 ; shift right 6 bits
sar ax, cl
jns continue ; is it positive?

2 Both the code and the reasons will be explained (but not
proved) in the summary.

The PC Assembler Tutor 60

and bx, bx ; is the remainder zero?
jz continue
inc ax

We get the remainder, then shift right 6 bits. Upon finishing
SAR, the sign flag will be set correctly. Here is yet another
jump. This one is JNS (jump on not sign) jumps if the sign flag
is NOT set, that is if the number is positive. If it is positive,
then everything is ok so we skip ahead. If the number is
negative, then we check to see if there was a remainder. If there
wasn't, everything is ok, so we go ahead. If there was a
remainder, then we INC (add 1) ax.

Is the remainder correct? If the number was positive, the
remainder is correct, but if the number was negative, then we
need to do one more thing. After INC, but before 'continue' we
have a SUB instruction:

inc ax
sub bx, 64 ; correct the remainder

Why that is the correct number will be explained in the summary.
What a lot of work when we could simply write:

mov cx, 64
call get_signed
cwd ; sign extend
idiv cx ; signed division

Is there any advantage to this instruction? Not really. Remember
that the more you shift, the longer it takes. If you shift 2,
then it's about 1/3 faster than division. If you shift 14, then
it is only 15% faster than division. Considering that even a slow
PC can do 25000 divisions a second, you must be in serious need
of speed to use this. In any case, you will never or almost never
use SAR for signed division, while you will find lots of
opportunity to use SHR and SHL for unsigned multiplication and


ROR (rotate right) and ROL (rotate left) rotate the bits around
the register. We will just do one program since they operate the
same way, only in opposite directions. Make another copy of
SAL.ASM and put in ROR in the appropriate spots.

Enter a number. This time you will notice that the bits, rather
than dissapearing off the end, reappear on the other side. They
rotate around the register. The only flags that are defined are
OF and CF. OF is set if the high bit changes, and CF is set if a
1 bit moves off the end of the register to the other side. Do a
few more, and we'll go on to the last two instructions.

Chapter 8 - Shift and Rotate 61


RCR (rotate through carry right) and RCL (rotate through carry
left) rotate the same as the above instructions except that the
carry flag is involved. Rotating right, the low bit moves to CF,
the carry flag and CF moves to the high bit. Rotating left, the
high bit moves to CF and CF moves to the low bit. There are 9
bits (or 17 bits for a word) involved in the rotation. Make yet
another copy of the program, and change those 4 instructions to
RCR. Also, since we have 9 bits instead of 8, change the loop
count to 9 from 8:

mov si, 9

Enter a number and watch it move. Before you start moving, look
at CF and see if there is anything in it. There are only two
flags defined, OF and CF. Obviously, CF is set if there is
something in it. OF is wierd. In RCL (the opposite instruction to
the one we are using), OF operates normally, signalling a change
in the top (sign) bit. In RCR, OF signals a change in CF. Why? I
don't have the slightest idea. You really have no need for the OF
flag anyways, so this is unimportant.

Well, those are the seven instructions, but what can you do with
them besides multiply and divide?

First, you can work with multiple bit data. The 8087 has a word
length register called the status register. Looking at the upper

15 14 13 12 11 10 9 8

bits 11, 12 and 13 contain a number from 0 to 7. The data in this
register is not directly accessable. You need to move the
register into memory, then into an 8086 register. If you want to
find what this number is, what do you do?

mov bx, status_register_data
mov cl, 3
ror bx, cl
and bh, 00000111b

we rotate right 3 and then mask off everything else. The number
is now in BH. We could have used SHR if we wanted. Another 8087
register is the control register. In the upper byte it has:

15 14 13 12 11 10 9 8

a number from 0 to 3 in bits 10 and 11. If we want the
information, we do the same thing:

mov bx, control_register_data
mov cl, 2
ror bx, cl

The PC Assembler Tutor 62

and bh, 00000011b

and the number is in BH.

You are now going to write a program that inputs an unsigned
number and prints out its hex representation. Here it is:

; + + + + + + + + + + + + + + + START CODE BELOW THIS LINE
mov ax_byte, 0A5h ; half regs, right ascii
mov bx_byte, 4 ; hex
mov dx_byte, 4 ; hex
lea ax, ax_byte
call set_reg_style
call show_regs

call get_unsigned
mov bx, ax
mov dx, ax
mov cx, 4
push cx ; save cx
mov cl, 4
rol bx, cl ; rotate left 1/2 byte
mov al, bl ; copy to al
and al, 0Fh ; mask off upper 1/2 byte
cmp al, 10 ; < 10, 0 - 9 ; > 9 A - F
jae use_letters
add al, '0' ; change to ascii
jmp print_it
add al, 'A' - 10 ; 10 = 'A'
call print_ascii_byte
call show_regs_and_wait
pop cx
loop inner_loop
jmp outer_loop
; + + + + + + + + + + + + + + + END CODE ABOVE THIS LINE

AL will be shown in ascii while BX and DX will be in hex. We save
the original number in DX. Since the first thing we want to print
is the left hex character, we rotate left, not right. We move the
low byte to AL, mask off everything but the low hex number and
then convert to an ascii character. If it is 0 - 9, we add '0'
(the character, not the number). If it is > 9, we add "'A' - 10"
and get a letter (if the number is 10, we get 'A'). JAE means
jump if above or equal, and is an unsigned comparison.{3}


3 You are getting innundated with conditional jump
instructions. Don't worry. As long as you understand each one
when you run across it, you don't have to remember it. All jump
instructions will be covered soon.

Chapter 8 - Shift and Rotate 63

Finally, we print the ascii character that is in AL.{4}

Another thing to notice is that just inside the loop we push CX.
That is because we use CL for the ROL instruction. It is then
POPped just before the loop instruction. This is typical. CX is
the only register that can be used for counting in indexed
instructions. It is common for indexing instructions to be
nested, so you temporarily store the old value of CX while you
are using CX for something different.

push cx ; typical code for a shift
mov cl, 7
shr si, cl
pop cx

Finally, let's multiply large numbers by 2. Here's the code:

; + + + + + + + + + + + + + + + START DATA BELOW THIS LINE
byte1 db ?
byte2 db ?
byte3 db ?
byte4 db ?
error_message db "Result is too large.", 0
; + + + + + + + + + + + + + + + END DATA ABOVE THIS LINE

; + + + + + + + + + + + + + + + START CODE BELOW THIS LINE
lea ax, byte1 ; get 4 byte number
call get_unsigned_4byte

shl byte1, 1
rcl byte2, 1
rcl byte3, 1
rcl byte4, 1
jnc go_on
lea ax, error_message
call print_string
lea ax, byte1
call print_unsigned_4byte
jmp outer_loop
; + + + + + + + + + + + + + + + END CODE ABOVE THIS LINE

This will require some explaination. Get_unsigned_4byte gets a
number from 1 to four billion. We put it in memory. Normally, the
following instructions would be done word by word. We are doing
them byte by byte so you can see the mechanics of the situation.
The low byte is shifted left 1 bit. This doubles it, but may
shift a 1 bit from the high bit into CF. If it does, then it will
be present when we rotate byte2. That moves CF into the low bit
and moves the high bit into CF. We do it again. And again. If
there is an unsigned overflow, it will be signalled by CF being

4 Any subroutine in ASMHELP.OBJ that involves a one byte input
or output has the data in AL.

The PC Assembler Tutor 64

set after:

rcl byte4, 1

JNC (jump on not carry) will skip the error message if everything
is ok. Print_string prints a zero terminated string, that is a C
string which is terminated by the number (not the character) 0.
Finally, we print the number.

A word about large numbers in ASMHELP.OBJ. It is assumed that you
would like to use commas if you could. Any data type over 1 word
long allows commas. The following are considered the same by
ASMHELP.OBJ in its input routines:


It always prints commas correctly in the print routines.

Chapter 8 - Shift and Rotate 65


All shift and rotate instructions operate on either a register or
on memory. They can be either 1 bit shifts:

sal cx, 1
ror variable1, 1
shr bl, 1

or shifts indexed by CL (it must be CL):

rcl variable2, cl
sar si, cl
rol ah, cl


SHL (shift logical left) and SAL (shift arithmetic left) are
exactly the same instruction. They move bits left. 0s are
placed in the low bit. Bits are shoved off the register (or
memory data) on the left side, and CF indicates whether the
last bit shoved was a 1 or a 0. It is used for multiplying
an unsigned number by powers of 2.


SHR (shift logical right) does the same thing as SHL but in
the opposite direction. Bits are shifted right. 0s are
placed in the high bit. Bits are shoved off the register (or
memory data) on the right side and CF indicates whether the
last bit shoved off was a 0 or a 1. It is used for dividing
an unsigned number by powers of 2.


SAR (shift arithmetic right) shifts bits right. The high
(sign) bit stays the same throughout the operation. Bits are
shoved off the register (or memory data) on the right side.
CF indicates whether the last bit shoved off was a 1 or a 0.
It is used (with difficulty) for dividing a signed number by
powers of 2.


ROR (rotate right) and ROL (rotate left) rotate the bits of
a register (or memory data) right and left respectively. The
bit which is shoved off one end is moved to the other end.
CF indicates whether the last bit moved from one end to the
other was a 1 or a 0.


The PC Assembler Tutor 66

RCR (rotate through carry right) and RCL (rotate through
carry left) rotate the bits of a register (or of memory
data) right and left respectively. The bit which is shoved
off the register (or data) is placed in CF and the old CF is
placed on the other side of the register (or data).

INC increments a register or a variable by 1.

inc ax
inc variable1

DEC decrements a register or a variable by 1.

dec ax
dec variable1

The following is fairly technical. It is only for those willing
to wade their way through a turgid explaination. If you don't
understand it, forget it.


If you are shifting an UNSIGNED number right by 'X' bits, it is
the same as dividing by (2 ** X) 1 bit = (2**1 = 2), 2 bits =
(2**2 = 4), 7 bits = (2**7 = 128). This is the same as dividing
by a number which is all 0s except the Xth bit which is 1 (for 0
we have 0000 0001, for 1 we have 0000 0010, for 3 we have 0000
1000, for 7 we have 1000 0000). The remainder mask will be this
number minus 1 (for 0 we have 0000 0000, for 1 we have 0000 0001,
for 3 we have 0000 0111, for 7 we have 0111 1111).


The order of numbers is important for SAR. If you start with 0
and add 1 each time, the actual sequence of signed numbers that
you get (from the bottom up) is:


Chapter 8 - Shift and Rotate 67

The positive numbers are increasing in absolute value while the
negative numbers are decreasing in absolute value. If you divide
by shifting and there is no remainder, then the quotient is
exact. If there is a remainder, the quotient will truncate
towards 0 IN THE ABOVE DIAGRAM. This means that positive numbers
will truncate down, while the negative numbers will truncate
towards -32768, and will be one too negative.

If the number was positive, the remainder will be positive and
will be exactly the same as for SHR. If the number was negative,
then things are more complicated. We'll take division by 32 as an
example. If we divide by 32 (0010 0000) the remainder mask will
be 31 (0001 1111). If the number is negative, then what we get
when we AND the mask:

and ax, 00011111b

is not the remainder but (remainder + 32). In order to get the
actual negative remainder, we need to subtract 32. This gives us
(remainder + 32 - 32).

remainder mask = divisor - 1
negative remainder correction = NEG divisor.