- 73 Views
- Uploaded on
- Presentation posted in: General

ECE291 Computer Engineering II Lecture 5

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

ECE291Computer Engineering IILecture 5

Josh Potts

University of Illinois at Urbana- Champaign

- Unconditional jump
- Conditional branching
- Construction of loops

ECE291

- Short jump2-byte instruction that allows jumps or branches to memory locations within +127 and -128 bytes from the memory location following the jump
JMPSHORT Label

- Near jump3-byte instruction that allows jumps or branches within +/- 32Kb from the instruction in the current code segment
JMPLabel

- Far jump5-byte instruction that allows a jump to any memory location with in the entire memory space
JMPLabel

- For 80386, 80486, the near jump is within +/-2G if the machine operates in the protected mode and +/-32K bytes if operates in the real mode

OPCODE DISP

OPCODE DISP low DISP high

OPCODE IP low IP high CS low CS high

ECE291

- Logic and arithmetic instructions set flags
- Flags provide state information from previous instruction(s)
- Using flags we can perform conditional jumping, i.e., transfer program execution to some different place within the program
if condition was true

- jump back or forward in your code to the location specified
- instruction pointer (IP) gets updated (to point to the instruction to which execution will jump)
if condition was false

- continue execution at the following instruction
- IP gets incremented as usual

ECE291

- Conditional jumps are always short jumps in the 8086-80286
- the range of the jump is +127 bytes and -128 bytes from the location following the conditional jump

- In 80386, 80486 conditional jumps are either short or near jumps
- Conditional jumps test: sign (S), zero (Z), carry (C), parity (P), and overflow (O)
- Note:
an FFh is above the 00h in the set of unsigned numbers

an FFh (-1) is less than 00h for signed numbers

when you compare unsigned FFh is above 00h, but

signed FFh is less than 00h

ECE291

- CMP(comparison) compares A to B
- a subtraction that only changes the flag bits
- useful for checking the entire contents of a register or a memory location against another value
- usually followed by a conditional jump instruction
CMPAL, 10h ;compare with 10h (contents of AL does not change)

JAESUBER ;if 10h or above then jump to memory location SUBER

- SUB (subtraction) calculates difference A - B
- saves results to A and set flags

ECE291

CMPOprnd1, Oprnd2

Unsigned OperandsSigned operands

Z: equality/inequality Z: equality/inequality

C: Oprnd1 < Oprnd2 (C=1) C: no meaning

Oprnd1 >= Oprnd2 (C=0)

S: no meaning S and O taken together

O: no meaningIf ((S=0) and (O=1)) or ((S=1) and (O=0)) then Oprnd1 < Oprnd2

If ((S=0) and (O=0)) or ((S=1) and (O=1)) then Oprnd1 >= Oprnd2

ECE291

- Consider CMP AX,BX computed by the CPU
- The Sign bit (S) will be set if the result of AX-BX has a 1 at the most significant bit of the result (i.e., 15th bit for 16-bit op)
- The Overflow flag (O) will be set if the result of AX-BX produced a number that was out of range (-32768 - 32767 for 16-bit numbers) to be represented by an integer.

- Difference in JS (jump on sign) and JL (jump less than)
- The conditional jump JS looks at the sign bit (S) of the last compare (or subtraction). If S = = 1 then jump.
- The conditional jump JL looks (SXOR O) of the last compare (or subtraction)
- REGARDLESS of the value AX-BX, i.e., even if AX-BX causes overflow, the JL will be correctly executed

ECE291

- JL is true if the condition: S xor O is met
- JL is true for two conditions:
- S=1, O=0:
- (AX-BX) was negative and (AX-BX) did not overflow
- Example (8-bit):
(-5) - (2) = (-7)

Result (-7) has the sign bit set

Thus (-5) is less than (2).

ECE291

- S=0, O=1:
- Overflow!,Sign bit of the result is wrong!
- Consider the following case:
AX is a large negative number (-)

BX is a positive number (+).

The subtraction of (-) and (+) is the same as the addition of (-) and (-)

The result causes negative overflow, and thus cannot berepresented as a signed integer correctly (O=1).

The result of AX-BX appears positive (S=0).

- Example (8-bit): (-128) - (1) = (+127)
- Result (+127) overflowed. Answer should have been (-129).
- Result appears positive, but overflow occurred
- Thus (-128) is less than (1), i.e., the condition is TRUE for executing JL

ECE291

AX

BX

AX

BX

BX

AX

-8

-8

-8

-7

-7

-7

-6

-6

-6

-5

-5

-5

-4

-4

-4

-3

-3

-3

-2

-2

-2

-1

-1

-1

0

0

0

1

1

1

2

2

2

3

3

3

4

4

4

5

5

5

6

6

6

7

7

7

AX – BX = 2 – (-4) = 2 + 4 = 6 =0110

So s = 0, no overflow (o = 0)

Therefore AX >= BX

AX – BX = 6 – (-3) = 6 + 3 = 9 = 1001

So s = 1, overflow (o = 1)

Therefore AX >= BX

AX – BX = 2 – 4 = -2 = 1110

So s = 1, no overflow (o = 0)

Therefore AX < BX

ECE291

- Terminology used to differentiate between jump instructions that use the carry flag and the overflow flag
- Above/Belowunsigned compare
- Greater/Lesssigned (+/-) compare

- Names of jump instructions
J => Jump

N => Not

A/B G/L=> Above/Below Greater/Less

E=>Equal

ECE291

CommandDescriptionCondition

JA=JNBEJump if above C=0 & Z=0

Jump if not below or equal

JBE=JNAJump if below or equalC=1 | Z=1

JAE=JNB=JNC Jump if above or equal C=0

Jump if not below

Jump if no carry

JB=JNAE=JC Jump if below C=1

Jump if carry

JE=JZ Jump if equal Z=1

Jump if Zero

JNE=JNZ Jump if not equalZ=0

Jump if not zero

JSJump Sign (MSB=1) S=1

ECE291

CommandDescriptionCondition

JNSJump Not Sign (MSB=0) S=0

JO Jump if overflow set O=1

JNOJump if no overflow O=0

JG=JNLE Jump if greater

Jump if not less or equal S=O & Z=0

JGE=JNLJump if greater or equal S=O

Jump if not less

JL=JNGEJump if less S^O

Jump if not greater or equal

JLE=JNG Jump if less or equal S^O | Z=1

Jump if not greater

JCXZJump if register CX=zero CX=0

ECE291

CMP AX, BX

JA true_label

….

<False Processing>

….

JMP done_label

….

true_label: <True processing>

….

done_label: <resume execution>

ECE291

ECE291

- LOOP instruction
- combination of a decrement CX and a conditional jump
- LOOP decrements CX (ECX if in 32-bit mode) and if CX 0 it jumps to the address indicated by the label
- if CX becomes a 0, the next sequential instruction executes
ADDSPROC NEAR

MOVCX, 100; load count

MOVSI, OFFSET BLOCK1

MOVDI, OFFSET BLOCK2

Again:

LODSW;get Block1 data; AX = [SI]; SI = SI + 2

ADDAX, ES:[DI];add Block2 data

STOSW;store in Block2; [DI] = AX; DI = DI + 2

LOOPAgain;repeat 100 times

RET

ADDSENDP

ECE291

;if (J <= K) then

;L := L + 1

;elseL := L - 1

; J, K, L are signed words

MOVAX, J

CMPAX, K

JNELDoElse

INCL

JMPifDone

DoElse:

DECL

ifDone:

;while (J >= K) do begin

;J := J - 1;

;K := K + 1;

;L := J * K;

;end;

WhlLoop:

MOVAX, J

CMPAX, K

JNGEQuitLoop

DECJ

INCK

MOVAX, J

IMULAX, K

MOVL, AX

JMPWhlLoop

QuitLoop:

ECE291

- The LOOPNE instruction is useful for controlling loops that stop on some condition or when the loop exceeds some number of iterations
- Consider String1 that contains a sequence of characters that end with the byte containing zero
- we want to convert those characters to upper case and copy them to String2
…..

String1BYTE“This string contains lower case characters”, 0

String2BYTE128 dup (0)

……..

ECE291

LEASI, String1 ;the same as use of OFFSET

LEADI, String2

MOVCX, 127;Max 127 chars to String2

StrLoop:

LODSB;get char from String1; AL =[SI]; SI = SI + 1

CMPAL, ‘a’;see if lower case

JBNotLower ;chars are unsigned

CMPAL, ‘z’

JANotLower

ANDAL, 5Fh;convert lower -> upper case; ;bit 6 must be 0

NotLower:

STOSB; [DI] = AL; DI = DI + 1

CMPAL, 0;see if zero terminator

LOOPNEStrLoop;quit if AL or CX = 0

ECE291