Loading in 5 sec....

ECE291 Computer Engineering II Lecture 5PowerPoint Presentation

ECE291 Computer Engineering II Lecture 5

- 100 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' ECE291 Computer Engineering II Lecture 5' - vivian

**An Image/Link below is provided (as is) to download presentation**

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

Presentation Transcript

Unconditional JumpJMP

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

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

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

- 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

Conditional Branching

- 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 Branching (cont.)

- 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

Numerical Comparison

- 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
CMP AL, 10h ;compare with 10h (contents of AL does not change)

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

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

ECE291

Numerical ComparisonCondition Code Settings

CMP Oprnd1, Oprnd2

Unsigned Operands Signed 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 meaning If ((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

Comparing Signed Integers

- 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

Comparing Signed Integers (cont.)

- 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

Comparing Signed Integers (cont.)

- 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 be represented 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

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

Comparing Signed IntegersCMP AX, BXAX – 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

Conditional Branching (cont.)

- Terminology used to differentiate between jump instructions that use the carry flag and the overflow flag
- Above/Below unsigned compare
- Greater/Less signed (+/-) compare

- Names of jump instructions
J => Jump

N => Not

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

E => Equal

ECE291

Summary of Conditional Jump Instructions

Command Description Condition

JA=JNBE Jump if above C=0 & Z=0

Jump if not below or equal

JBE=JNA Jump if below or equal C=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 equal Z=0

Jump if not zero

JS Jump Sign (MSB=1) S=1

ECE291

Summary of Conditional Jump Instructions

Command Description Condition

JNS Jump Not Sign (MSB=0) S=0

JO Jump if overflow set O=1

JNO Jump if no overflow O=0

JG=JNLE Jump if greater

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

JGE=JNL Jump if greater or equal S=O

Jump if not less

JL=JNGE Jump 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

JCXZ Jump if register CX=zero CX=0

ECE291

Mapping High Level Branches into Linear Code

CMP AX, BX

JA true_label

….

<False Processing>

….

JMP done_label

….

true_label: <True processing>

….

done_label: <resume execution>

ECE291

Mapping High Level Branches into Linear Code (cont.)

ECE291

Mapping High Level Branches into Linear Code (cont.)

- 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
ADDS PROC NEAR

MOV CX, 100 ; load count

MOV SI, OFFSET BLOCK1

MOV DI, OFFSET BLOCK2

Again:

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

ADD AX, ES:[DI] ;add Block2 data

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

LOOP Again ;repeat 100 times

RET

ADDS ENDP

ECE291

; L := L + 1

; else L := L - 1

; J, K, L are signed words

MOV AX, J

CMP AX, K

JNEL DoElse

INC L

JMP ifDone

DoElse:

DEC L

ifDone:

; while (J >= K) do begin

; J := J - 1;

; K := K + 1;

; L := J * K;

; end;

WhlLoop:

MOV AX, J

CMP AX, K

JNGE QuitLoop

DEC J

INC K

MOV AX, J

IMUL AX, K

MOV L, AX

JMP WhlLoop

QuitLoop:

ExamplesECE291

Example (LOOPNE)

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

String1 BYTE “This string contains lower case characters”, 0

String2 BYTE 128 dup (0)

……..

ECE291

Example (LOOPNE)

LEA SI, String1 ;the same as use of OFFSET

LEA DI, String2

MOV CX, 127 ;Max 127 chars to String2

StrLoop:

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

CMP AL, ‘a’ ;see if lower case

JB NotLower ;chars are unsigned

CMP AL, ‘z’

JA NotLower

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

NotLower:

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

CMP AL, 0 ;see if zero terminator

LOOPNE StrLoop ;quit if AL or CX = 0

ECE291

Download Presentation

Connecting to Server..