Lecture 6 conditional processing l.jpg
This presentation is the property of its rightful owner.
Sponsored Links
1 / 63

Lecture 6 Conditional Processing PowerPoint PPT Presentation


  • 142 Views
  • Uploaded on
  • Presentation posted in: General

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 :

Download Presentation

Lecture 6 Conditional Processing

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


    Jumps based on specific flags l.jpg

    Jumps Based on Specific Flags


    Jumps based on equality l.jpg

    Jumps Based on Equality


    Jumps based on unsigned comparisons l.jpg

    Jumps Based on Unsigned Comparisons


    Jumps based on signed comparisons l.jpg

    Jumps Based on Signed Comparisons


    Applications 1 of 5 l.jpg

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

    • Solution: Use CMP, followed by JA

    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

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

    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

    • Compare unsigned AX to BX, and copy the larger of the two into a variable named Large

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

    • 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

    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

    • 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

    • LOOPZ and LOOPE

    • LOOPNZ and LOOPNE


    Loopz and loope l.jpg

    LOOPZ and LOOPE

    • 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

    • 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

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

    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)

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

    • 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

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

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

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

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

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

    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

    • Runtime Expressions

    • Relational and Logical Operators

    • MASM-Generated Code

    • .REPEAT Directive

    • .WHILE Directive


    Runtime expressions l.jpg

    Runtime Expressions

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


    Masm generated code l.jpg

    MASM-Generated Code

    .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

    .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

    .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

    .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

    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

    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

    • Introducing Macros

    • Defining Macros

    • Invoking Macros

    • Macro Examples

    • Nested Macros

    • Example Program: Wrappers


    Introducing macros l.jpg

    Introducing Macros

    • 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

    • 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

    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

    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:

    1push eax

    1mov al,'A'

    1call WriteChar

    1pop eax

    viewed in the listing file

    Expansion:


    Invoking macros 1 of 2 l.jpg

    Invoking Macros (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 (2 of 2)

    Relationships between macros, arguments, and parameters:


    Mwritestr macro 1 of 2 l.jpg

    mWriteStr Macro (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 (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

    1push edx

    1mov edx,OFFSET str1

    1call WriteString

    1pop edx


    Invalid argument l.jpg

    Invalid Argument

    • 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

    1push eax

    1mov al,1234h; error!

    1call WriteChar

    1pop eax

    .code

    mPutchar 1234h


    Blank argument l.jpg

    Blank Argument

    • 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

    1push eax

    1mov al,

    1call WriteChar

    1pop eax


    Your turn63 l.jpg

    Your turn . . .

    • 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


  • Login