EEL 3801

1
EEL 3801

• Part V
• Conditional Processing

2
Conditional 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.

3
BOOLEAN 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.

4
BOOLEAN 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).

5
BOOLEAN 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).

6
The 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

7
The 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.

8
The 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.

9
The 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

10
The 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

11
The 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

12
The XOR Instruction (cont.)

• Applications
• Reversing bits
• Encrypting information (applying it twice will
  return the original bit).

13
The 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

14
The 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

15
The 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.

16
The 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

17
The 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.

18
The 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.

19
The 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

20
The 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.

21
Example

• 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

22
Conditional 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.

23
Conditional 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.

24
Conditional 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.

25
Conditional 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.

26
Examples

• mov ax,var1
• mov bx,var2
• cmp ax,bx
• je equal
• not_equal
• ltstatement1gt
• ltstatement2gt
• jmp exit
• equal
• ltstatement3gt
• ltstatement4gt
• exit

27
Examples (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.

28
Conditional 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.

29
The 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.

30
Example - 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

31
The 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.

32
Example - 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

33
High 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.

34
The 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

35
The IF Statement (cont.)

• cmp op1,op2 sets flags
• je next_label
• jmp endif
• next_label
• ltstatement 1gt
• ltstatement 2gt
• end_if
• .
• .

36
The 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

37
The 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

38
The While Structure (cont.)

• do_while
• cmp op1,op2
• jnl enddo
• ltstatement1gt
• ltstatement2gt
• jmp do_while
• enddo

39
The Repeat-Until Structure

• You get the picture.

40
The 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).

41
Shift 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.

42
The 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

43
The 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.

44
SHL - Example

• shl bl,1
• shl wordval,1
• shl byte ptrsi,1
• mov cl,4
• shl al,cl

45
The 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.

46
The 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.

47
The 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.

48
The 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.

49
The 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

50
The 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

51
The RCL and RCR Instructions

• Self-explanatory based on the above.

52
Example

• 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

53
Example

• 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

54
Multiple 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.

55
The 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.