Lecture 6 conditional processing
Download
1 / 63

Lecture 6 Conditional Processing - PowerPoint PPT Presentation


  • 174 Views
  • Updated On :

Lecture 6 Conditional Processing. Assembly Language for Intel-Based Computers , 4th edition Kip R. Irvine. Outline. Boolean and Comparison Instructions Conditional Jumps Conditional Loops High-Level Logic Structures. Logic Instructions. Syntax for AND, OR, XOR, and TEST :

Related searches for Lecture 6 Conditional Processing

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 'Lecture 6 Conditional Processing' - libby


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
Lecture 6 conditional processing l.jpg

Lecture 6Conditional Processing

Assembly Language for

Intel-Based Computers,

4th edition

Kip R. Irvine


Outline l.jpg
Outline

  • Boolean and Comparison Instructions

  • Conditional Jumps

  • Conditional Loops

  • High-Level Logic Structures


Logic instructions l.jpg
Logic Instructions

  • Syntax for AND, OR, XOR, and TEST:

    • op-code destination, source

  • AND, OR and XOR perform the Boolean bitwise operation and store the result into destination.

  • TEST is just an AND but the result is not stored

  • Both operands must be of the same type

    • either byte, word or doubleword

  • Both operands cannot be memory at same time

    • again: memory to memory operations are forbidden

  • They modify OF, CF, SF, ZF, PF according to the result of the operation (as usual)


Logic instructions cont l.jpg
Logic Instructions (cont.)

  • The source is often an immediate operand called a bit mask: used to fix certain bits to 0 or 1

  • To clear a bit we use an AND since:

    • 0 AND b = 0 (b is cleared)

    • 1 AND b = b (b is conserved)

  • Ex: to clear the sign bit of AL without affecting the others, we do:

    • AND al,7Fh ;msb of AL is clearedsince 7Fh = 0111 1111b


Logic instructions cont5 l.jpg
Logic Instructions (cont.)

  • To set (ie: set to 1) certain bits, we use OR:

    • 1 OR b = 1 (b is set)

    • 0 OR b = b (b is conserved)

  • To set the sign bit of AH, we do:

    • OR ah,80h

  • To test if ECX=0 we can do:

    • OR ecx,ecx

    • since this does not change the number in ECX and set ZF=1 if and only if ecx=0


Logic instructions cont6 l.jpg
Logic Instructions (cont.)

  • XOR can be used to complement, conserve, or clear certain bits because:

    • b XOR 1 = NOT(b) (b is complemented)

    • b XOR 0 = b (b is conserved)

    • b XOR b = 0 (b is cleared)

  • Ex: to initialize a register to 0 we can use a two-byte instruction:

    • XOR ax,ax

    • instead of the three-byte instruction:

    • MOV ax,0This was faster on 8088's


Logic instructions cont7 l.jpg
Logic Instructions (cont.)

  • Using OR and XOR in strange ways:

  • XOR ax, ax MOV ax, 0 OR ax, ax CMP ax, 0bytes 2 386/88 3 cycles 4 cycles286 2 cycles 2 cycles386 2 cycles 2 cycles486 1 cycle 1 cycle

  • Machine code33 C0 B8 0000 0B C0 83 F8 00


Logic instructions cont8 l.jpg
Logic Instructions (cont.)

  • To convert from upper case to lower case we can use the usual method:

    • ADD dl,20h

  • But "A" = 0100 0001b "a" = 0110 0001b

    • OR dl,20h;converts from upper to lower case

    • AND dl,0DFh;converts from lower to upper casesince DFh = 1101 1111b

  • OR dl,20h and AND dh, 20hleaves lower case characters in dl unchanged and upper case characters in dh unchanged

Bit 5


Logic instructions cont9 l.jpg
Logic Instructions (cont.)

  • To invert all the bits (ones complement):

    • NOT destination

    • does not affect any flag and destination cannot be an immediate operand

  • Reflection

    • What are the easiest ways to clearing or setting individual CPU flags?


The cmp instruction l.jpg
The CMP instruction

  • CMP destination,source

  • Performs: destination - source but does not store the result of this subtraction into destination

  • But the flags are affected like SUB

  • Same restrictions on operands as SUB

  • Very often used just before performing a conditional jump

  • CMP is similar to TEST except TEST does AND operation


  • Conditional jumps l.jpg
    Conditional Jumps

    • Jumps Based On . . .

      • Specific flags

      • Equality

      • Unsigned comparisons

      • Signed Comparisons

    • Applications

    • Encrypting a String

    • Bit Test (BT) Instruction


    J cond instruction l.jpg
    Jcond Instruction

    • A conditional jump instruction branches to a label when specific register or flag conditions are met

    • Examples:

      • JB, JC jump to a label if the Carry flag is set

      • JE, JZ jump to a label if the Zero flag is set

      • JS jumps to a label if the Sign flag is set

      • JNE, JNZ jump to a label if the Zero flag is clear

      • JECXZ jumps to a label if ECX equals 0






    Applications 1 of 5 l.jpg

    cmp eax,ebx

    ja Larger

    • Task: Jump to a label if signed EAX is greater than EBX

    • Solution: Use CMP, followed by JG

    cmp eax,ebx

    jg Greater

    Applications (1 of 5)


    Applications 2 of 5 l.jpg

    cmp eax,Val1

    jbe L1 ; below or equal

    • Jump to label L1 if signed EAX is less than or equal to Val1

    cmp eax,Val1

    jle L1

    Applications (2 of 5)


    Applications 3 of 5 l.jpg

    • mov Large,bx

    • cmp ax,bx

    • jna Next

    • mov Large,ax

  • Next:

    • Compare signed AX to BX, and copy the smaller of the two into a variable named Small

    • mov Small,ax

    • cmp bx,ax

    • jnl Next

    • mov Small,bx

  • Next:

  • Applications (3 of 5)


    Applications 4 of 5 l.jpg
    Applications into a variable named (4 of 5)

    • Jump to label L1 if the memory word pointed to by ESI equals Zero

    • cmp WORD PTR [esi],0

    • je L1

    • Jump to label L2 if the doubleword in memory pointed to by EDI is even

    test DWORD PTR [edi],1

    jz L2


    Applications 5 of 5 l.jpg
    Applications into a variable named (5 of 5)

    • Task: Jump to label L1 if bits 0, 1, and 3 in AL are all set.

    • Solution: Clear all bits except bits 0, 1,and 3. Then compare the result with 00001011 binary.

    and al,00001011b ; clear unwanted bits

    cmp al,00001011b ; check remaining bits

    je L1 ; all set? jump to L1


    Your turn l.jpg
    Your turn . . . into a variable named

    • Write code that jumps to label L1 if either bit 4, 5, or 6 is set in the BL register.

    • Write code that jumps to label L1 if bits 4, 5, and 6 are all set in the BL register.

    • Write code that jumps to label L3 if EAX is negative.


    Encrypting a string l.jpg
    Encrypting a String into a variable named

    The following loop uses the XOR instruction to transform every character in a string into a new value.

    • KEY = 239 ; can be any byte value

    • BUFMAX = 128

    • .data

    • buffer BYTE BUFMAX+1 DUP(0)

    • bufSize DWORD BUFMAX

    • .code

      • mov ecx,bufSize ; loop counter

      • mov esi,0 ; index 0 in buffer

    • L1:

      • xor buffer[esi],KEY ; translate a byte

      • inc esi ; point to next byte

      • loop L1


    String encryption program l.jpg
    String Encryption Program into a variable named

    • Tasks:

      • Input a message (string) from the user

      • Encrypt the message

      • Display the encrypted message

      • Decrypt the message

      • Display the decrypted message

    View the Encrypt.asm program's source code. Sample output:

    Enter the plain text: Attack at dawn.

    Cipher text: «¢¢Äîä-Ä¢-ïÄÿü-Gs

    Decrypted: Attack at dawn.


    Conditional loop instructions l.jpg
    Conditional Loop Instructions into a variable named

    • LOOPZ and LOOPE

    • LOOPNZ and LOOPNE


    Loopz and loope l.jpg
    LOOPZ and LOOPE into a variable named

    • Syntax:

      LOOPE destination

      LOOPZ destination

    • Logic:

      • ECX  ECX – 1

      • if ECX > 0 and ZF=1, jump to destination

    • Useful when scanning an array for the first element that does not match a given value.


    Loopnz and loopne l.jpg
    LOOPNZ and LOOPNE into a variable named

    • LOOPNZ (LOOPNE) is a conditional loop instruction

    • Syntax:

      LOOPNZ destination

      LOOPNE destination

    • Logic:

      • ECX  ECX – 1;

      • if ECX > 0 and ZF=0, jump to destination

    • Useful when scanning an array for the first element that matches a given value.


    Loopnz example l.jpg
    LOOPNZ Example into a variable named

    The following code finds the first positive value in an array:

    • .data

    • array SWORD -3,-6,-1,-10,10,30,40,4

    • sentinel SWORD 0

    • .code

      • mov esi,OFFSET array

      • mov ecx,LENGTHOF array

    • next:

      • test WORD PTR [esi],8000h ; test sign bit

      • pushfd ; push flags on stack

      • add esi,TYPE array

      • popfd ; pop flags from stack

      • loopnz next ; continue loop

      • jnz quit ; none found

      • sub esi,TYPE array ; ESI points to value

    • quit:


    Your turn29 l.jpg
    Your turn . . . into a variable named

    Locate the first nonzero value in the array. If none is found, let ESI point to the sentinel value:

    • .data

    • array SWORD 50 DUP(?)

    • sentinel SWORD 0FFFFh

    • .code

      • mov esi,OFFSET array

      • mov ecx,LENGTHOF array

    • L1: cmp WORD PTR [esi],0 ; check for zero

    • (fill in your code here)

    • quit:


    Solution l.jpg
    . . . (solution) into a variable named

    • .data

    • array SWORD 50 DUP(?)

    • sentinel SWORD 0FFFFh

    • .code

      • mov esi,OFFSET array

      • mov ecx,LENGTHOF array

    • L1: cmp WORD PTR [esi],0 ; check for zero

      • pushfd ; push flags on stack

      • add esi,TYPE array

      • popfd ; pop flags from stack

      • loope L1 ; continue loop

      • jz quit ; none found

      • sub esi,TYPE array ; ESI points to value

    • quit:


    Conditional structures l.jpg
    Conditional Structures into a variable named

    • Block-Structured IF Statements

    • Compound Expressions with AND

    • Compound Expressions with OR

    • WHILE Loops

    • Table-Driven Selection


    Block structured if statements l.jpg
    Block-Structured IF Statements into a variable named

    Assembly language programmers can easily translate logical statements written in C++/Java into assembly language. For example:

    if( op1 == op2 )

    X = 1;

    else

    X = 2;

    • mov eax,op1

    • cmp eax,op2

    • jne L1

    • mov X,1

    • jmp L2

  • L1: mov X,2

  • L2:


  • Your turn33 l.jpg
    Your turn . . . into a variable named

    Implement the following pseudocode in assembly language. All values are unsigned:

    if( ebx <= ecx )

    {

    eax = 5;

    edx = 6;

    }

    • cmp ebx,ecx

    • ja next

    • mov eax,5

    • mov edx,6

  • next:

  • (There are multiple correct solutions to this problem.)


    Your turn34 l.jpg
    Your turn . . . into a variable named

    Implement the following pseudocode in assembly language. All values are 32-bit signed integers:

    if( var1 <= var2 )

    var3 = 10;

    else

    {

    var3 = 6;

    var4 = 7;

    }

    • mov eax,var1

    • cmp eax,var2

    • jle L1

    • mov var3,6

    • mov var4,7

    • jmp L2

  • L1: mov var3,10

  • L2:

  • (There are multiple correct solutions to this problem.)


    Compound expression with and 1 of 3 l.jpg
    Compound Expression with AND into a variable named (1 of 3)

    • When implementing the logical AND operator, consider that HLLs use short-circuit evaluation

    • In the following example, if the first expression is false, the second expression is skipped:

    if (al > bl) AND (bl > cl)

    X = 1;


    Compound expression with and 2 of 3 l.jpg
    Compound Expression with AND into a variable named (2 of 3)

    if (al > bl) AND (bl > cl)

    X = 1;

    This is one possible implementation . . .

    cmp al,bl ; first expression...

    ja L1

    jmp next

    L1:

    cmp bl,cl ; second expression...

    ja L2

    jmp next

    L2: ; both are true

    mov X,1 ; set X to 1

    next:


    Compound expression with and 3 of 3 l.jpg
    Compound Expression with AND into a variable named (3 of 3)

    if (al > bl) AND (bl > cl)

    X = 1;

    But the following implementation uses 29% less code by reversing the first relational operator. We allow the program to "fall through" to the second expression:

    cmp al,bl ; first expression...

    jbe next ; quit if false

    cmp bl,cl ; second expression...

    jbe next ; quit if false

    mov X,1 ; both are true

    next:


    Your turn38 l.jpg
    Your turn . . . into a variable named

    Implement the following pseudocode in assembly language. All values are unsigned:

    if( ebx <= ecx

    && ecx > edx )

    {

    eax = 5;

    edx = 6;

    }

    • cmp ebx,ecx

    • ja next

    • cmp ecx,edx

    • jbe next

    • mov eax,5

    • mov edx,6

  • next:

  • (There are multiple correct solutions to this problem.)


    Compound expression with or 1 of 2 l.jpg
    Compound Expression with OR into a variable named (1 of 2)

    • When implementing the logical OR operator, consider that HLLs use short-circuit evaluation

    • In the following example, if the first expression is true, the second expression is skipped:

    if (al > bl) OR (bl > cl)

    X = 1;


    Compound expression with or 1 of 240 l.jpg
    Compound Expression with OR into a variable named (1 of 2)

    if (al > bl) OR (bl > cl)

    X = 1;

    We can use "fall-through" logic to keep the code as short as possible:

    cmp al,bl ; is AL > BL?

    ja L1 ; yes

    cmp bl,cl ; no: is BL > CL?

    jbe next ; no: skip next statement

    L1: mov X,1 ; set X to 1

    next:


    While loops l.jpg

    This is a possible implementation: into a variable named

    top: cmp eax,ebx ; check loop condition

    jae next ; false? exit loop

    inc eax ; body of loop

    jmp top ; repeat the loop

    next:

    WHILE Loops

    A WHILE loop is really an IF statement followed by the body of the loop, followed by an unconditional jump to the top of the loop. Consider the following example:

    while( eax < ebx)

    eax = eax + 1;


    Your turn42 l.jpg
    Your turn . . . into a variable named

    Implement the following loop, using unsigned 32-bit integers:

    while( ebx <= val1)

    {

    ebx = ebx + 5;

    val1 = val1 - 1

    }

    top: cmp ebx,val1 ; check loop condition

    ja next ; false? exit loop

    add ebx,5 ; body of loop

    dec val1

    jmp top ; repeat the loop

    next:


    Using the if directive l.jpg
    Using the .IF Directive into a variable named

    • Runtime Expressions

    • Relational and Logical Operators

    • MASM-Generated Code

    • .REPEAT Directive

    • .WHILE Directive


    Runtime expressions l.jpg
    Runtime Expressions into a variable named

    • .IF, .ELSE, .ELSEIF, and .ENDIF can be used to evaluate runtime expressions and create block-structured IF statements.

    • Examples:

    .IF eax > ebx

    mov edx,1

    .ELSE

    mov edx,2

    .ENDIF

    .IF eax > ebx && eax > ecx

    mov edx,1

    .ELSE

    mov edx,2

    .ENDIF

    • MASM generates "hidden" code for you, consisting of code labels, CMP and conditional jump instructions.


    Relational and logical operators l.jpg
    Relational and Logical Operators into a variable named


    Masm generated code l.jpg
    MASM-Generated Code into a variable named

    .data

    val1 DWORD 5

    result DWORD ?

    .code

    mov eax,6

    .IF eax > val1

    mov result,1

    .ENDIF

    Generated code:

    mov eax,6

    cmp eax,val1

    jbe @C0001

    mov result,1

    @C0001:

    MASM automatically generates an unsigned jump (JBE) because val1 is unsigned.


    Masm generated code47 l.jpg
    MASM-Generated Code into a variable named

    .data

    val1 SDWORD 5

    result SDWORD ?

    .code

    mov eax,6

    .IF eax > val1

    mov result,1

    .ENDIF

    Generated code:

    mov eax,6

    cmp eax,val1

    jle @C0001

    mov result,1

    @C0001:

    MASM automatically generates a signed jump (JLE) because val1 is signed.


    Masm generated code48 l.jpg
    MASM-Generated Code into a variable named

    .data

    result DWORD ?

    .code

    mov ebx,5

    mov eax,6

    .IF eax > ebx

    mov result,1

    .ENDIF

    Generated code:

    mov ebx,5

    mov eax,6

    cmp eax,ebx

    jbe @C0001

    mov result,1

    @C0001:

    MASM automatically generates an unsigned jump (JBE) when both operands are registers . . .


    Masm generated code49 l.jpg
    MASM-Generated Code into a variable named

    .data

    result SDWORD ?

    .code

    mov ebx,5

    mov eax,6

    .IF SDWORD PTR eax > ebx

    mov result,1

    .ENDIF

    Generated code:

    mov ebx,5

    mov eax,6

    cmp eax,ebx

    jle @C0001

    mov result,1

    @C0001:

    . . . unless you prefix one of the register operands with the SDWORD PTR operator. Then a signed jump is generated.


    Repeat directive l.jpg
    .REPEAT Directive into a variable named

    Executes the loop body before testing the loop condition associated with the .UNTIL directive.

    Example:

    ; Display integers 1 – 10:

    mov eax,0

    .REPEAT

    inc eax

    call WriteDec

    call Crlf

    .UNTIL eax == 10


    While directive l.jpg
    .WHILE Directive into a variable named

    Tests the loop condition before executing the loop body The .ENDW directive marks the end of the loop.

    Example:

    ; Display integers 1 – 10:

    mov eax,0

    .WHILE eax < 10

    inc eax

    call WriteDec

    call Crlf

    .ENDW


    Macros l.jpg
    Macros into a variable named

    • Introducing Macros

    • Defining Macros

    • Invoking Macros

    • Macro Examples

    • Nested Macros

    • Example Program: Wrappers


    Introducing macros l.jpg
    Introducing Macros into a variable named

    • A macro1 is a named block of assembly language statements.

    • Once defined, it can be invoked (called) one or more times.

    • During the assembler's preprocessing step, each macro call is expanded into a copy of the macro.

    • The expanded code is passed to the assembly step, where it is checked for correctness.

    1Also called a macro procedure.


    Defining macros l.jpg
    Defining Macros into a variable named

    • A macro must be defined before it can be used.

    • Parameters are optional.

    • Each parameter follows the rules for identifiers. It is a string that is assigned a value when the macro is invoked.

    • Syntax:

    macroname MACRO [parameter-1, parameter-2,...]

    statement-list

    ENDM


    Mnewline macro example l.jpg
    mNewLine Macro Example into a variable named

    This is how you define and invoke a simple macro.

    mNewLine MACRO ; define the macro

    call Crlf

    ENDM

    .data

    .code

    mNewLine ; invoke the macro

    The assembler will substitute "call crlf" for "mNewLine".


    Mputchar macro l.jpg
    mPutChar Macro into a variable named

    Writes a single character to standard output.

    mPutchar MACRO char

    push eax

    mov al,char

    call WriteChar

    pop eax

    ENDM

    Definition:

    .code

    mPutchar 'A'

    Invocation:

    1 push eax

    1 mov al,'A'

    1 call WriteChar

    1 pop eax

    viewed in the listing file

    Expansion:


    Invoking macros 1 of 2 l.jpg
    Invoking Macros into a variable named (1 of 2)

    • When you invoke a macro, each argument you pass matches a declared parameter.

    • Each parameter is replaced by its corresponding argument when the macro is expanded.

    • When a macro expands, it generates assembly language source code.

    • Arguments are treated as simple text by the preprocessor.


    Invoking macros 2 of 2 l.jpg
    Invoking Macros into a variable named (2 of 2)

    Relationships between macros, arguments, and parameters:


    Mwritestr macro 1 of 2 l.jpg
    mWriteStr Macro into a variable named (1 of 2)

    Provides a convenient way to display a string, by passing the string name as an argument.

    mWriteStr MACRO buffer

    push edx

    mov edx,OFFSET buffer

    call WriteString

    pop edx

    ENDM

    .data

    str1 BYTE "Welcome!",0

    .code

    mWriteStr str1


    Mwritestr macro 2 of 2 l.jpg
    mWriteStr Macro into a variable named (2 of 2)

    The expanded code shows how the str1 argument replaced the parameter named buffer:

    mWriteStr MACRO buffer

    push edx

    mov edx,OFFSET buffer

    call WriteString

    pop edx

    ENDM

    1 push edx

    1 mov edx,OFFSET str1

    1 call WriteString

    1 pop edx


    Invalid argument l.jpg
    Invalid Argument into a variable named

    • If you pass an invalid argument, the error is caught when the expanded code is assembled.

    • Example:

    mPutchar MACRO char

    push eax

    mov al,char

    call WriteChar

    pop eax

    ENDM

    1 push eax

    1 mov al,1234h ; error!

    1 call WriteChar

    1 pop eax

    .code

    mPutchar 1234h


    Blank argument l.jpg
    Blank Argument into a variable named

    • If you pass a blank argument, the error is also caught when the expanded code is assembled.

    • Example:

    mPutchar MACRO char

    push eax

    mov al,char

    call WriteChar

    pop eax

    ENDM

    .code

    mPutchar

    1 push eax

    1 mov al,

    1 call WriteChar

    1 pop eax


    Your turn63 l.jpg
    Your turn . . . into a variable named

    • Write a macro named mMove32 that receives two 32-bit memory operands. The macro should move the source operand to the destination operand.

    . . . Solution

    mMove32 MACRO destination,source

    push eax

    mov eax,source

    mov destination,eax

    pop eax

    ENDM


    ad