ece291 computer engineering ii lecture 5
Download
Skip this Video
Download Presentation
ECE291 Computer Engineering II Lecture 5

Loading in 2 Seconds...

play fullscreen
1 / 20

ECE291 Computer Engineering II Lecture 5 - PowerPoint PPT Presentation


  • 100 Views
  • Uploaded on

ECE291 Computer Engineering II Lecture 5. Josh Potts University of Illinois at Urbana- Champaign. Outline. Unconditional jump Conditional branching Construction of loops. Unconditional Jump JMP.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
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
ece291 computer engineering ii lecture 5

ECE291Computer Engineering IILecture 5

Josh Potts

University of Illinois at Urbana- Champaign

outline
Outline
  • Unconditional jump
  • Conditional branching
  • Construction of loops

ECE291

unconditional jump jmp
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
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 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
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 comparison condition code settings
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
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
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 cont1
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

comparing signed integers cmp ax bx

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

Comparing Signed IntegersCMP AX, BX

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

conditional branching cont1
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
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 instructions1
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
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 cont1
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

examples
; if (J <= K) then

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

Examples

ECE291

example loopne
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 loopne1
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

ad