Ece291 computer engineering ii lecture 5
Download
1 / 20

ECE291 Computer Engineering II Lecture 5 - PowerPoint PPT Presentation


  • 97 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 cont
Mapping High Level Branches into Linear Code (cont.)

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