Title: EEL 3801
1EEL 3801
- Part V
- Conditional Processing
2Conditional Processing
- This section explains how to implement
conditional processing in Assembly Language for
the 8086/8088 processors. - While loops are explicitly implemented in
Assembly, conditional structures are not so. - They must be implemented by using some rather
complex instructions.
3BOOLEAN and COMPARISON Instructions
- Boolean logic has long been a part of computers.
- In fact, these instructions form the basis of
processor instructions. - All instructions to be discussed affect several
of the flags, such as the Zero Flag, the Carry
Flag and the Sign Flag.
4BOOLEAN and COMPARISON Instructions (cont.)
- Other less important flags are also affected, but
these are the major ones. - Zero Flag (ZF) set when result of operation 0.
- Carry Flag (CF) set when result of unsigned
addition is too large for destination, or when a
subtraction requires a borrow (result is lt 0).
5BOOLEAN and COMPARISON Instructions (cont.)
- Sign Flag (SF) set when the high bit of a signed
number operand is set, indicating a negative
number. - Overflow Flag (OF) set when the result of a
signed arithmetic operation is too large for
destination operand (out of range).
6The AND Instruction
- Performs a boolean AND operation on two 8-bit or
16-bit binary numbers. - Places the result in the destination operand.
- Format is
- AND destination,source
7The AND Instruction (cont.)
- Only one of the operands may be a memory operand,
- they must both be of the same size.
- This instruction, as well as all other boolean
operations, works on a bit-by-bit basis, - comparing the bits in the respective positions
in the destination and the source.
8The AND Instruction (cont.)
- If the two corresponding bits are both set, then
the corresponding bit in the destination is set
( 1). Otherwise, it is cleared ( 0). - Applications
- Bit masking (clearing certain bits).
- See page 181 of new book for specific examples.
9The OR Instruction
- Performs a boolean OR operation between two 8- or
16-bit binary numbers. - If corresponding bits are both 0, then resulting
bit will be 0 - Otherwise, resulting bit is set to 1. Its format
is - OR destination,source
10The OR Instruction
- Only one of the operands may be a memory operand,
- they must both be of the same size.
- Applications
- Checking the sign or value by looking at the
flags - Convert a binary digit to the ASCII equivalent
- Setting status bit values
11The XOR Instruction
- Performs the EXCLUSIVE OR operation.
- Same basic idea applies as the other two
instructions, - except that the resulting bit is 1 if the source
and destination are different, 0 if they are the
same. - The format is
- XOR destination,source
12The XOR Instruction (cont.)
- Applications
- Reversing bits
- Encrypting information (applying it twice will
return the original bit).
13The NOT Instruction
- Reverses the value of each bit.
- Same as the negation operation in boolean
algebra. - This amounts to computing the ones complement of
the operand. - The format is
- NOT destination
14The NEG Instruction
- Reverses the sign of a signed number.
- This is done by computing its twos complement
(take the ones complement and add 1b). - The format is
- NEG destination
15The NEG Instruction (cont.)
- Check the Overflow Flag after this operation to
ensure that the resulting operand is valid. - For example, if we NEG 128, the result is 128,
which is invalid. - The OF should be set when this happens,
indicating that this is not a valid operation.
16The TEST Instruction
- Performs an implied AND operation that does not
change the destination, but affects the flags as
does the AND. - The format is
- TEST destination,source
17The TEST Instruction (cont.)
- The important thing is that if any of the
matching bit positions are set in both operands,
the Zero Flag is cleared. - Applications
- Useful when trying to determine whether any
individual bits in an operand are set.
18The TEST Instruction (cont.)
- To implement the application
- Put an operand with the bit set on the bit needed
to be ascertained, and all others cleared. - If ZF 0, we know that that bit (or bits) are
set. - If ZF 1, then it/they are not set.
19The CMP Instruction
- Offers a way to compare 8- or 16-bit operands.
- The result can be read from the Flag register.
- The format
- CMP destination,source
20The CMP Instruction (cont.)
- This instruction subtracts one operand from the
other (destination source). - However, neither operand is actually modified.
- If destination gt source, CF 0, ZF 0
- If destination source, ZF1
- If destination lt source, CF 1.(produces a
borrow) - This is the basis of conditional jumps.
21Example
- mov al,5
- cmp al,10 5-10lt0 sets carry flag (CF1)
- mov ax,1000
- mov cx,1000
- cmp cx,ax 1000 1000 0, ? ZF1
- mov si,105
- cmp si,0 105 - 0 gt0, CF0, ZF0
22Conditional Jumps
- There are no assembly language equivalents to the
high level language conditional structures. - However, the same thing can be concocted by
combining several of the instructions provided in
the instruction set of the 8086/8088 processor. - This is the topic in this section.
23Conditional Jumps (cont.)
- This can be done with 2 groups of instructions
- Comparison and arithmetic operations
(instructions) in which certain flags are set. - Conditional jump instructions in which the CPU
takes action according to the values of the flags
involved.
24Conditional Jumps (cont.)
- There are several such conditional jump
instructions. - They all have the format
- Jcond destination
- Where the condition is different depending on the
instruction. - The destination address must be between 128 and
127 bytes away from instruction.
25Conditional Jumps (cont.)
- There are several such conditions
- pg. 194 (new book) for unsigned comparisons,
- pg. 193 (new book) for signed comparisons.
- They all depend on one or more flags in the Flag
Register, but mainly on ZF, CF, OF, SF, and PF
(parity flag). - One of them (JCXZ) makes use of the CX register.
26Examples
- mov ax,var1
- mov bx,var2
- cmp ax,bx
- je equal
- not_equal
- ltstatement1gt
- ltstatement2gt
- jmp exit
- equal
- ltstatement3gt
- ltstatement4gt
- exit
27Examples (cont.)
- If var1 var2, then statements 3 and 4 will be
executed. - If var1 lt var2, then statements 1 and 2 will be
executed. - If var1 gt var2, then statements 1 and 2 will be
executed.
28Conditional Loops
- The same thing applies to conditional loops.
- They now not only depend on the non-zero value of
CX register, but also on some other condition,
such as a flag register. - Only when these 2 conditions are satisfied will
the instructions loop around again.
29The LOOPZ Instruction
- Continues to loop as long as CX gt 0, and ZF 1.
- The format is as follows
- LOOPZ destination
- Where the destination must be within 128 and 127
bytes from the LOOPZ instruction.
30Example - Scanning an Array
- Scan an array of integer values until a non-zero
is found then stop. - mov bx,offset intarray moves array address
- sub bx,2 back up one word
- mov cx,100 repeat 100 times
- next
- add bx,2 move pointer up one
- cmp word ptr bx,0 check if zero
- loopz next if so, go to next
31The LOOPNZ Instruction
- This is the opposite of the LOOPZ instruction.
- This one continues to loop as long as CXgt0 and
ZF0. - It has the same identical syntax as LOOPZ, with
the same conditions of proximity for the
destination.
32Example - Scanning an Array
- Scan an array of integers for the first positive
number. - array db -3,-6,-1,-10,10,30,40,4
- array_len equ -array
- .
- mov si,offset array-1
- mov cx,array_len
- next
- inc si
- test byte ptr si,80h 10000000b
- loopnz next
33High Level Logic Structures
- There are other logic structures in high level
languages that may be desirable to duplicate in
assembly. - These are discussed here briefly.
34The IF Statement
- This can be easily done with the instructions
that have already been described. - For example, to execute several instructions if
one operand equals the other, see the code in the
following slide
35The IF Statement (cont.)
- cmp op1,op2 sets flags
- je next_label
- jmp endif
- next_label
- ltstatement 1gt
- ltstatement 2gt
- end_if
- .
- .
36The IF Statement (cont.)
- Can also be combined with the OR operator (not
instruction) - cmp al,op1
- jg L1
- cmp al,op2
- jge L1
- cmp al,op3
- je L1
- cmp al,op4
- jl L1
- jmp L2
- L1
- ltstatement1gt
- L2
37The While Structure
- Tests a condition before performing a block of
instructions. - Repeats the instructions as long as the statement
is true. - This can be easily represented as follows
38The While Structure (cont.)
- do_while
- cmp op1,op2
- jnl enddo
- ltstatement1gt
- ltstatement2gt
- jmp do_while
- enddo
39The Repeat-Until Structure
40The CASE Structure
- Same as the switch structure in C, where
depending on what the value of a variable is, the
control branches to several different places. - Same idea as the others above.
- See page 209 (new book).
41Shift and Rotate Instructions
- These instructions allow for messing with the
bits. - Interestingly enough, C allows such bit-level
manipulations. - Can be used to do high-speed multiplication,
where you multiply the operand by 2 to the power
of how many times ever you shift to the left.
42The Shift Left Instruction (SHL)
- The SHL instruction shifts each bit in the
destination operand by 1 position to the left. - The high bit is moved to the Carry Flag, the low
bit is cleared ( 0), and the old bit on the
Carry Flag is lost. - Can also shift left a specific number of
positions. The format is - SHL destination,1 or
- SHL destination,CL
43The Shift Left Instruction (SHL) (cont.)
- If CL is used as the source operand, then the
value of CL represents how many times to shift
left. - The value can be from 0 to 255.
- CL is not changed.
- Both register and memory operands may be used.
44SHL - Example
- shl bl,1
- shl wordval,1
- shl byte ptrsi,1
- mov cl,4
- shl al,cl
45The Shift Left Instruction (SHL) (cont.)
- Can be used to do high-speed multiplication,
- you multiply the operand by 2 to the power of how
many times ever you shift to the left.
46The Shift Right Instruction (SHR)
- Same as SHL, except that it shifts right instead
of left. - SHR destination,1 or
- SHR destination,CL
- Where CL is the number of shifts to be made.
- Can be used to divide by a power of 2.
47The SAL and SAR Instructions
- SAL stands for Shift Arithmetic Left
- SAR stands for Shift Arithmetic Right
- Same as SHL and SHR except these are specifically
for signed operands. - SAL is in truth identical to SHL and is included
only for the sake of completeness. - SAR shifts each bit to the right, but makes a
copy of the sign bit.
48The SAL and SAR Instructions (cont.)
- It copies the lowest bit of the destination
operand into the Carry Flag - Shifts the operand right 1 bit position
- Duplicates the original sign bit.
49The Rotate Left (ROL) Instruction
- Moves each bit to the left
- but the highest bit is copied into the Carry Flag
and to the lowest bit. - Can be used to exchange the high and low halves
of an operand. - Has the same format as the Shift Instructions
- ROL destination,1 or
- ROL destination,cl
50The Rotate Right (ROR) Instruction
- Same as ROL except it rotates to the right.
- The lowest bit is copied into
- the Carry Flag. and
- the highest bit.
- The format is
- ROR destination,1 or
- ROR destination,cl
51The RCL and RCR Instructions
- Self-explanatory based on the above.
52Example
- Can be used for multiplication, even if neither
operand is a power of 2. - This can be done if the operand can be obtained
by adding two numbers that are a power of 2. - For example if we multiply any number (contained
in a variable called intval) by 36, we could
multiply it by (32 4), both of which are powers
of 2
53Example
- mov bx,intval move integer to BX
- mov cl,5 multiply x 25 32
- shl bx,cl shift left 5 times
- mov product,bx store result
- mov bx,intval do it again
- shl bx,1 mult by 2
- shl bx,1 mult by 2 again
- add product,bx add results
54Multiple Addition and Subtraction
- The ADD and SUB instructions allow for adding and
subtracting only two operands. - This can be rather limiting.
- Much better can be done with an instruction that
can carry out a sum or subtraction of several
operands.
55The ADC Instruction
- The Add with Carry Instruction allows for
addition and subtraction of multiple operands. - It permits both the source operand and the carry
Flag to be added to the destination.