Conditional Processing COE 205 Computer Organization and Assembly
Conditional Processing COE 205 Computer Organization and Assembly Language Dr. Aiman El-Maleh College of Computer Sciences and Engineering King Fahd University of Petroleum and Minerals [Adapted from slides of Dr. Kip Irvine: Assembly Language for Intel-Based Computers]
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 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 00111011 00001111 00001011 COE 205 – KFUPM unchanged slide 3
Converting Characters to Uppercase v AND instruction can convert characters to uppercase 'a' = 0 1 1 0 0 1 'b' = 0 1 1 0 0 0 1 0 'A' = 0 1 0 0 0 1 'B' = 0 1 0 v Solution: Use the AND instruction to clear bit 5 L 1: mov ecx, LENGTHOF mystring mov esi, OFFSET mystring and BYTE PTR [esi], 11011111 b ; clear bit 5 inc esi loop L 1 Conditional Processing COE 205 – KFUPM 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 00111011 11110000 11111011 COE 205 – KFUPM unchanged slide 5
Converting Characters to Lowercase v OR instruction can convert characters to lowercase 'A' = 0 1 0 0 0 1 'B' = 0 1 0 'a' = 0 1 1 0 0 1 'b' = 0 1 1 0 0 0 1 0 v Solution: Use the OR instruction to set bit 5 L 1: mov ecx, LENGTHOF mystring mov esi, OFFSET mystring or BYTE PTR [esi], 20 h inc esi ; set bit 5 loop L 1 Conditional Processing COE 205 – KFUPM slide 6
Converting Binary Digits to ASCII v OR instruction can convert a binary digit to ASCII 0 =0000 1 =00000001 '0' = 0 0 1 1 0 0 '1' = 0 0 1 1 0 0 0 1 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 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 00111011 11110000 11001011 COE 205 – KFUPM unchanged 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 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 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 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 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 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 SUB ² 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 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 1 unsigned destination > unsigned source 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 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 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 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 unsigned comparisons ² Jumps based on the value of CX or ECX Conditional Processing COE 205 – KFUPM 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 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 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 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 JB condition CF = 1 COE 205 – KFUPM 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 JL condition OF ≠ SF COE 205 – KFUPM 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 JGE condition OF = SF COE 205 – KFUPM 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 ; assume Min = eax ; Min = ebx COE 205 – KFUPM 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 ; je found ; add esi, 4 ; loop L 1 notfound: mov esi, -1 ; found: ret ; search ENDP Conditional Processing array element = search value? yes? found element no? point to next array element if not found then esi = -1 if found, esi = element address COE 205 – KFUPM 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 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 slide 28
LOOPE and LOOPZ v Syntax: LOOPE destination LOOPZ destination v Logic: ² 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 slide 29
LOOPNE and LOOPNZ v Syntax: LOOPNE destination LOOPNZ 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 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 slide 31
Your Turn. . . Locate the first zero value in an array If none is found, let ESI be initialized to -1. 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 JE Found MOV ESI, -1 Found: Conditional Processing COE 205 – KFUPM 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 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 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 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 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 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 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 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 ; ; ; AL < yes? AL > yes? ZF = COE 205 – KFUPM '0' ? ZF=0, return '9' ? ZF=0, return 1 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 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 ; ; eax < ebx ? false? then exit loop body of loop repeat the loop COE 205 – KFUPM 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 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 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 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 or register § Address is stored in memory/register § Address is absolute v Syntax: JMP mem 32/reg 32 ² 32 -bit absolute address is stored in mem 32/reg 32 for FLAT memory v Indirect jump is used to implement switch statements Conditional Processing COE 205 – KFUPM 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 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 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 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 slide 50
Bubble Sort v Consider sorting an array of 5 elements: 5 1 3 2 4 First Pass (4 comparisons) Compare 5 with 1 and swap: Compare 5 with 3 and swap: Compare 5 with 2 and swap: Compare 5 with 4 and swap: 5 1 1 1 5 3 3 3 5 2 2 2 5 4 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 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 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 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 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 slide 55
- Slides: 55