Conditional Processing COE 205 Computer Organization and Assembly

Conditional Processing COE 205 Computer Organization and Assembly Language Computer Engineering Department King Fahd University of Petroleum and Minerals

Presentation Outline v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 2

AND Instruction v Bitwise AND between each pair of matching bits AND destination, source v Following operand combinations are allowed AND AND AND reg, mem, reg mem imm reg imm v AND instruction is often used to clear selected bits Conditional Processing AND Operands can be 8, 16, or 32 bits and they must be of the same size AND cleared COE 205 – KFUPM 00111011 00001111 00001011 unchanged © Muhamed Mudawar – slide 3

Converting Characters to Uppercase v AND instruction can convert characters to uppercase 'a' = 0 1 1 0 0 1 'b' =01100010 'A' = 0 1 0 0 0 1 'B' =01000010 v Solution: Use the AND instruction to clear bit 5 mov ecx, LENGTHOF mystring mov esi, OFFSET mystring L 1: and bit 5 inc BYTE PTR [esi], 11011111 b ; clear esi loop L 1 Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 4

OR Instruction v Bitwise OR operation between each pair of matching bits OR destination, source v Following operand combinations are allowed OR OR OR reg, mem, reg mem imm reg imm v OR instruction is often used to set selected bits Conditional Processing OR Operands can be 8, 16, or 32 bits and they must be of the same size OR set COE 205 – KFUPM 00111011 11110000 11111011 unchanged © Muhamed Mudawar – slide 5

Converting Characters to Lowercase v OR instruction can convert characters to lowercase 'A' = 0 1 0 0 0 1 'B' =01000010 'a' = 0 1 1 0 0 1 'b' =01100010 v Solution: Use the OR instruction to set bit 5 L 1: 5 mov ecx, LENGTHOF mystring mov esi, OFFSET mystring or BYTE PTR [esi], 20 h inc esi ; set bit loop L 1 Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 6

Converting Binary Digits to ASCII v OR instruction can convert a binary digit to ASCII 0 =0000 1 =00000001 '0' =00110000 '1' =00110001 v Solution: Use the OR instruction to set bits 4 and 5 or al, 30 h ; Convert binary digit 0 to 9 to ASCII v What if we want to convert an ASCII digit to binary? v Solution: Use the AND instruction to clear bits 4 to 7 and al, 0 Fh Conditional Processing ; Convert ASCII '0' to '9' to binary COE 205 – KFUPM © Muhamed Mudawar – slide 7

XOR Instruction v Bitwise XOR between each pair of matching bits XOR destination, source v Following operand combinations are allowed XOR XOR XOR reg, mem, reg mem imm reg imm v XOR instruction is often used to invert selected bits Conditional Processing XOR Operands can be 8, 16, or 32 bits and they must be of the same size XOR inverted COE 205 – KFUPM 00111011 11110000 11001011 unchanged © Muhamed Mudawar – slide 8

Affected Status Flags The six status flags are affected 1. Carry Flag: Cleared by AND, OR, and XOR 2. Overflow Flag: Cleared by AND, OR, and XOR 3. Sign Flag: Copy of the sign bit in result 4. Zero Flag: Set when result is zero 5. Parity Flag: Set when parity in least-significant byte is even 6. Auxiliary Flag: Undefined by AND, OR, and XOR Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 9

String Encryption Program v Tasks: ² Input a message (string) from the user ² Encrypt the message ² Display the encrypted message ² Decrypt the message ² Display the decrypted message v Sample Output Enter the plain text: Attack at dawn. Cipher text: «¢¢Äîä-Ä¢-ïÄÿü-Gs Decrypted: Attack at dawn. Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 10

Encrypting a String KEY = 239 ; Can be any byte value BUFMAX = 128. data buffer BYTE BUFMAX+1 DUP(0) buf. Size DWORD BUFMAX The following loop uses the XOR instruction to transform every character in a string into a new value mov ecx, buf. Size mov esi, 0 ; loop counter ; index 0 in buffer L 1: xor buffer[esi], KEY ; translate a byte inc esi ; point to next byte loop L 1 Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 11

TEST Instruction v Bitwise AND operation between each pair of bits TEST destination, source v The flags are affected similar to the AND Instruction v However, TEST does NOT modify the destination operand v TEST instruction can check several bits at once ² Example: Test whether bit 0 or bit 3 is set in AL ² Solution: test al, 00001001 b ; test bits 0 & 3 ² We only need to check the zero flag ; If zero flag => both bits 0 and 3 are clear ; If Not zero Conditional Processing => either bit 0 or 3 is set COE 205 – KFUPM © Muhamed Mudawar – slide 12

NOT Instruction v Inverts all the bits in a destination operand NOT destination v Result is called the 1's complement v Destination can be a register or memory NOT reg NOT mem v None of the Flags is affected by the NOT instruction Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 13

CMP Instruction v CMP (Compare) instruction performs a subtraction Syntax: CMP destination, source Computes: destination – source v Destination operand is NOT modified v All six flags: OF, CF, SF, ZF, AF, and PF are affected v CMP uses the same operand combinations as AND ² Operands can be 8, 16, or 32 bits and must be of the same size v Examples: assume EAX = 5, EBX = 10, and ECX = 5 cmp eax, ebx cmp eax, ecx Conditional Processing ; OF=0, CF=1, SF=1, ZF=0 ; OF=0, CF=0, SF=0, ZF=1 COE 205 – KFUPM © Muhamed Mudawar – slide 14

Unsigned Comparison v CMP can perform unsigned and signed comparisons ² The destination and source operands can be unsigned or signed v For unsigned comparison, we examine ZF and CF flags Unsigned Comparison ZF CF unsigned destination < unsigned source 0 1 unsigned destination > unsigned source 0 0 destination = source 1 0 To check for equality, it is enough to check ZF flag v CMP does a subtraction and CF is the borrow flag CF = 1 if and only if unsigned destination < unsigned source v Assume AL = 5 and BL = -1 = FFh cmp al, bl ; Sets carry flag CF = 1 Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 15

Signed Comparison v For signed comparison, we examine SF, OF, and ZF Signed Comparison Flags signed destination < signed source SF ≠ OF signed destination > signed source SF = OF, ZF = 0 destination = source ZF = 1 v Recall for subtraction, the overflow flag is set when … ² Operands have different signs and result sign ≠ destination sign v CMP AL, BL (consider the four cases shown below) Case 1 AL = 80 BL = 50 OF = 0 SF = 0 AL > BL Case 2 AL = -80 BL = -50 OF = 0 SF = 1 AL < BL Case 3 AL = 80 BL = -50 OF = 1 SF = 1 AL > BL Case 4 AL = -80 BL = 50 OF = 1 SF = 0 AL < BL Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 16

Next. . . v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 17

Conditional Structures v No high-level control structures in assembly language v Comparisons and conditional jumps are used to … ² Implement conditional structures such as IF statements ² Implement conditional loops v Types of Conditional Jump Instructions ² Jumps based on specific flags ² Jumps based on equality ² Jumps based on the value of CX or ECX ² Jumps based on unsigned comparisons ² Jumps based on signed comparisons Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 18

Jumps Based on Specific Flags v Conditional Jump Instruction has the following syntax: Jcond destination ; cond is the jump condition v Destination Label v Prior to 386 Jump must be within – 128 to +127 bytes from current location v IA-32 32 -bit offset permits jump anywhere in memory Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 19

Jumps Based on Equality v JE is equivalent to JZ v. JNE is equivalent to JNZ jecxz L 2 ; exit loop v JECXZ Checked once at the beginning L 1: . . . Terminate a loop if ECX is zero loop L 1 ; loop body L 2: Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 20

Examples of Jump on Zero v Task: Check whether integer value in EAX is even Solution: TEST whether the least significant bit is 0 If zero, then EAX is even, otherwise it is odd test eax, 1 jz Even. Val ; test bit 0 of eax ; jump if Zero flag is set v Task: Jump to label L 1 if bits 0, 1, and 3 in AL are all set Solution: and al, 00001011 b cmp al, 00001011 b je L 1 Conditional Processing ; clear bits except 0, 1, 3 ; check bits 0, 1, 3 ; all set? jump to L 1 COE 205 – KFUPM © Muhamed Mudawar – slide 21

Jumps Based on Unsigned Comparison Task: Jump to a label if unsigned EAX is less than EBX Solution: Conditional Processing cmp eax, ebx jb Is. Below COE 205 – KFUPM JB condition CF = 1 © Muhamed Mudawar – slide 22

Jumps Based on Signed Comparisons Task: Jump to a label if signed EAX is less than EBX Solution: Conditional Processing cmp eax, ebx jl Is. Less COE 205 – KFUPM JL condition OF ≠ SF © Muhamed Mudawar – slide 23

Compare and Jump Examples Jump to L 1 if unsigned EAX is greater than Var 1 Solution: cmp eax, Var 1 ja L 1 JA condition CF = 0, ZF = 0 Jump to L 1 if signed EAX is greater than Var 1 Solution: cmp eax, Var 1 jg L 1 JG condition OF = SF, ZF = 0 Jump to L 1 if signed EAX is greater than or equal to Var 1 Solution: Conditional Processing cmp eax, Var 1 jge L 1 COE 205 – KFUPM JGE condition OF = SF © Muhamed Mudawar – slide 24

Computing the Max and Min v Compute the Max of unsigned EAX and EBX Solution: mov cmp jae mov done: Max, eax Max, ebx done Max, ebx ; assume Max = eax ; Max = ebx v Compute the Min of signed EAX and EBX Solution: Conditional Processing mov cmp jle mov done: Min, eax Min, ebx done Min, ebx COE 205 – KFUPM ; assume Min = eax ; Min = ebx © Muhamed Mudawar – slide 25

Application: Sequential Search ; Receives: esi = array address ; ecx = array size ; eax = search value ; Returns: esi = address of found element search PROC USES ecx jecxz notfound L 1: cmp [esi], eax ; array element = search value? je found ; yes? found element add esi, 4 ; no? point to next array element loop L 1 notfound: mov esi, 0 ; if not found then esi = 0 found: ret ; if found, esi = element address search ENDP Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 26

BT Instruction v BT = Bit Test Instruction v Syntax: BT r/m 16, r 16 BT r/m 32, r 32 BT r/m 16, imm 8 BT r/m 32, imm 8 v Copies bit n from an operand into the Carry flag v Example: jump to label L 1 if bit 9 is set in AX register bt AX, 9 jc L 1 Conditional Processing ; CF = bit 9 ; jump if Carry to L 1 COE 205 – KFUPM © Muhamed Mudawar – slide 27

Next. . . v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 28

LOOPZ and LOOPE v Syntax: LOOPE destination LOOPZ destination v Logic: ² ECX = ECX – 1 ² if ECX > 0 and ZF=1, jump to destination v Useful when scanning an array for the first element that does not match a given value. Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 29

LOOPNZ and LOOPNE v Syntax: LOOPNZ destination LOOPNE destination v Logic: ² ECX – 1; ² if ECX > 0 and ZF=0, jump to destination v Useful when scanning an array for the first element that matches a given value. Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 30

LOOPZ Example The following code finds the first negative value in an array. data array SWORD 17, 10, 30, 4, -5, 8. code mov esi, OFFSET array – 2 ; start before first mov ecx, LENGTHOF array ; loop counter L 1: add esi, 2 ; point to next element test WORD PTR [esi], 8000 h ; test sign bit loopz L 1 ; ZF = 1 if value >= 0 jnz found ; found negative value notfound: . . . ; ESI points to last array element found: . . . ; ESI points to first negative value Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 31

Your Turn. . . Locate the first zero value in an array If none is found, let ESI point to last array element. data array SWORD -3, 7, 20, -50, 10, 0, 4. code mov esi, OFFSET array – 2 ; start before first mov ecx, LENGTHOF array ; loop counter L 1: add esi, 2 ; point to next element cmp WORD PTR [esi], 0 ; check for zero loopne L 1 ; continue if not zero jz found ; found zero notfound: . . . ; ESI points to last array value found: . . . ; ESI points to first zero value Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 32

Next. . . v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 33

Block-Structured IF Statements v IF statement in high-level languages (such as C or Java) ² Boolean expression (evaluates to true or false) ² List of statements performed when the expression is true ² Optional list of statements performed when expression is false v Task: Translate IF statements into assembly language v Example: if( var 1 == var 2 ) X = 1; else X = 2; Conditional Processing mov eax, var 1 cmp eax, var 2 jne elsepart mov X, 1 jmp next elsepart: mov X, 2 next: COE 205 – KFUPM © Muhamed Mudawar – slide 34

Your Turn. . . v Translate the IF statement to assembly language v All values are unsigned if( ebx <= ecx ) { eax = 5; edx = 6; } cmp ja mov next: ebx, ecx next eax, 5 edx, 6 There can be multiple correct solutions Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 35

Your Turn. . . v Implement the following IF in assembly language v All variables are 32 -bit signed integers if (var 1 var 3 = } else { var 3 = var 4 = } <= var 2) { 10; 6; 7; mov eax, var 1 cmp eax, var 2 jle ifpart mov var 3, 6 mov var 4, 7 jmp next ifpart: mov var 3, 10 next: There can be multiple correct solutions Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 36

Compound Expression with AND v HLLs use short-circuit evaluation for logical AND v If first expression is false, second expression is skipped if ((al > bl) && (bl > cl)) {X = 1; } ; One Possible Implementation. . . cmp al, bl ; first expression. . . ja L 1 ; unsigned comparison jmp next L 1: cmp bl, cl ; second expression. . . ja L 2 ; unsigned comparison jmp next L 2: mov X, 1 ; both are true next: Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 37

Better Implementation for AND if ((al > bl) && (bl > cl)) {X = 1; } The following implementation uses less code By reversing the relational operator, We allow the program to fall through to the second expression Number of instructions is reduced from 7 to 5 cmp jbe mov next: Conditional Processing al, bl next bl, cl next X, 1 ; ; ; first expression. . . quit if false second expression. . . quit if false both are true COE 205 – KFUPM © Muhamed Mudawar – slide 38

Your Turn. . . v Implement the following IF in assembly language v All values are unsigned if ((ebx <= ecx) && (ecx > edx)) { eax = 5; edx = 6; } Conditional Processing cmp ja cmp jbe mov next: COE 205 – KFUPM ebx, ecx next ecx, edx next eax, 5 edx, 6 © Muhamed Mudawar – slide 39

Application: Is. Digit Procedure Receives a character in AL Sets the Zero flag if the character is a decimal digit if (al >= '0' && al <= '9') {ZF = 1; } Is. Digit PROC cmp al, '0' jb L 1 cmp al, '9' ja L 1 test al, 0 L 1: ret Is. Digit ENDP Conditional Processing ; ; ; COE 205 – KFUPM AL < yes? AL > yes? ZF = '0' ? ZF=0, return '9' ? ZF=0, return 1 © Muhamed Mudawar – slide 40

Compound Expression with OR v HLLs use short-circuit evaluation for logical OR v If first expression is true, second expression is skipped if ((al > bl) || (bl > cl)) {X = 1; } v Use fall-through to keep the code as short as possible cmp ja cmp jbe L 1: mov next: Conditional Processing al, bl L 1 bl, cl next X, 1 ; ; ; is AL > BL? yes, execute if part no: is BL > CL? no: skip if part set X to 1 COE 205 – KFUPM © Muhamed Mudawar – slide 41

WHILE Loops A WHILE loop can be viewed as IF statement followed by The body of the loop, followed by Unconditional jump to the top of the loop while( eax < ebx) { eax = eax + 1; } This is a possible implementation: top: cmp jae inc jmp next: Conditional Processing eax, ebx next eax top ; ; COE 205 – KFUPM eax < ebx ? false? then exit loop body of loop repeat the loop © Muhamed Mudawar – slide 42

Your Turn. . . Implement the following loop, assuming unsigned integers while (ebx <= var 1) { ebx = ebx + 5; var 1 = var 1 - 1 } top: cmp ja add dec jmp next: Conditional Processing ebx, var 1 next ebx, 5 var 1 top ; ebx <= var 1? ; false? exit loop ; execute body of loop ; repeat the loop COE 205 – KFUPM © Muhamed Mudawar – slide 43

Yet Another Solution for While Check the loop condition at the end of the loop No need for JMP, loop body is reduced by 1 instruction while (ebx <= var 1) { ebx = ebx + 5; var 1 = var 1 - 1 } cmp ja top: add dec cmp jbe next: Conditional Processing ebx, var 1 next ebx, 5 var 1 ebx, var 1 top ; ebx <= var 1? ; false? exit loop ; execute body of loop ; ebx <= var 1? ; true? repeat the loop COE 205 – KFUPM © Muhamed Mudawar – slide 44

Next. . . v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 45

Indirect Jump v Direct Jump: Jump to a Labeled Destination ² Destination address is a constant § Address is encoded in the jump instruction § Address is an offset relative to EIP (Instruction Pointer) v Indirect jump ² Destination address is a variable § Address is stored in memory § Address is absolute v Syntax: JMP mem 32 ² 32 -bit absolute address is stored in mem 32 for FLAT memory v Indirect jump is used to implement switch statements Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 46

Switch Statement v Consider the following switch statement: Switch (ch) { case '0': case '1': case '2': case '3': case '4': default : } exit(); count++; break; count--; break; count += 5; break; count -= 5; break; count = 0; v How to translate above statement into assembly code? v We can use a sequence of compares and jumps v A better solution is to use the indirect jump Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 47

Implementing the Switch Statement case 0: exit case 1: inc count jmp exitswitch case 2: dec count jmp exitswitch case 3: add count, 5 jmp exitswitch case 4: sub count, 5 jmp exitswitch default: mov count, 0 exitswitch: Conditional Processing There are many case labels. How to jump to the correct one? Answer: Define a jump table and use indirect jump to the correct label COE 205 – KFUPM © Muhamed Mudawar – slide 48

Jump Table and Indirect Jump v Jump Table is an array of double words ² Contains the case labels of the switch statement ² Can be defined inside the same procedure of switch statement jumptable DWORD case 0, case 1, case 2, case 3, case 4 Assembler converts labels to addresses v Indirect jump uses jump table to jump to selected label movzx sub cmp ja jmp Conditional Processing eax, ch ; eax, '0' ; eax, 4 ; default ; jumptable[eax*4] move ch to eax convert ch to a number eax > 4 ? default case ; Indirect jump COE 205 – KFUPM © Muhamed Mudawar – slide 49

Next. . . v Boolean and Comparison Instructions v Conditional Jumps v Conditional Loop Instructions v Translating Conditional Structures v Indirect Jump and Table-Driven Selection v Application: Sorting an Integer Array Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 50

Bubble Sort v Consider sorting an array of 5 elements: 5 1 3 2 4 First Pass (4 comparisons) 5 1 3 2 4 Compare 5 with 1 and swap: 1 5 3 2 Compare 5 with 3 and swap: 1 3 5 2 Compare 5 with 2 and swap: 1 3 2 5 Compare 5 with 4 and swap: 1 3 2 4 4 5 (swap) largest Second Pass (3 comparisons) Compare 1 with 3 (No swap): Compare 3 with 2 and swap: Compare 3 with 4 (No swap): 1 3 2 4 5 1 2 3 4 5 (no swap) Third Pass (2 comparisons) Compare 1 with 2 (No swap): Compare 2 with 3 (No swap): 1 2 3 4 5 (no swap) No swapping during 3 rd pass array is now sorted Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 51

Bubble Sort Algorithm v Algorithm: Sort array of given size bubble. Sort(array, size) { comparisons = size do { comparisons--; sorted = true; // assume initially for (i = 0; i<comparisons; i++) { if (array[i] > array[i+1]) { swap(array[i], array[i+1]); sorted = false; } } } while (! sorted) } Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 52

Bubble Sort Procedure – Slide 1 of 2 ; -------------------------; bubble. Sort: Sorts a DWORD array in ascending order ; Uses the bubble sort algorithm ; Receives: ESI = Array Address ; ECX = Array Length ; Returns: Array is sorted in place ; -------------------------bubble. Sort PROC USES eax ecx edx outerloop: dec ECX ; ECX = comparisons jz sortdone ; if ECX == 0 then we are done mov EDX, 1 ; EDX = sorted = 1 (true) push ECX ; save ECX = comparisons push ESI ; save ESI = array address Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 53

Bubble Sort Procedure – Slide 2 of 2 innerloop: mov EAX, [ESI] cmp EAX, [ESI+4] jle increment xchg EAX, [ESI+4] mov [ESI], EAX mov EDX, 0 increment: add ESI, 4 loop innerloop pop ESI pop ECX cmp EDX, 1 jne outerloop sortdone: ret bubble. Sort ENDP Conditional Processing ; compare [ESI] and [ESI+4] ; [ESI]<=[ESI+4]? don’t swap ; swap [ESI] and [ESI+4] ; EDX = sorted = 0 (false) ; ; ; point to next element end of inner loop restore ESI = array address restore ECX = comparisons sorted == 1? No? loop back ; return COE 205 – KFUPM © Muhamed Mudawar – slide 54

Summary v Bitwise instructions (AND, OR, XOR, NOT, TEST) ² Manipulate individual bits in operands v CMP: compares operands using implied subtraction ² Sets condition flags for later conditional jumps and loops v Conditional Jumps & Loops ² Flag values: JZ, JNZ, JC, JNC, JO, JNO, JS, JNS, JP, JNP ² Equality: JE(JZ), JNE (JNZ), JCXZ, JECXZ ² Signed: JG (JNLE), JGE (JNL), JL (JNGE), JLE (JNG) ² Unsigned: JA (JNBE), JAE (JNB), JB (JNAE), JBE (JNA) ² LOOPZ (LOOPE), LOOPNZ (LOOPNE) v Indirect Jump and Jump Table Conditional Processing COE 205 – KFUPM © Muhamed Mudawar – slide 55