Unconditional jump Conditional branching



Yüklə 228 Kb.
tarix07.11.2018
ölçüsü228 Kb.
#78725



  • Unconditional jump

  • Conditional branching

  • Construction of loops



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

  • Short jump 2-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 jump 3-byte instruction that allows jumps or branches within +/- 32Kb from the instruction in the current code segment

    • JMP Label
  • Far jump 5-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



Logic and arithmetic instructions set flags

  • 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


Conditional jumps are always short jumps in the 8086-80286

  • 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


CMP(comparison) compares A to B

  • 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


CMP Oprnd1, Oprnd2

  • CMP Oprnd1, Oprnd2



Consider CMP AX,BX computed by the CPU

  • 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 (S XOR O) of the last compare (or subtraction)


  • 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).



S=0, O=1:

  • 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




Terminology used to differentiate between jump instructions that use the carry flag and the overflow flag

  • 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



Command Description Condition

  • 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



Command Description Condition

  • 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







LOOP instruction

  • 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


; if (J <= K) then

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



The LOOPNE instruction is useful for controlling loops that stop on some condition or when the loop exceeds some number of iterations

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

  • ……..



LEA SI, String1 ;the same as use of OFFSET

  • 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



Yüklə 228 Kb.

Dostları ilə paylaş:




Verilənlər bazası müəlliflik hüququ ilə müdafiə olunur ©genderi.org 2024
rəhbərliyinə müraciət

    Ana səhifə