Download Assembly Language of 8086: Instruction Set and Data Transfer and more Exams Engineering in PDF only on Docsity!
Module 2
Contents
Description of Instructions Assembly directives Algorithms with assembly software programs Module 2 learning unit 5
Data Transfer InstructionsGENERAL – PURPOSE BYTE OR WORD
TRANSFER INSTRUCTIONS:
¾MOV
¾PUSH
¾POP
¾XCHG
¾XLAT
SIMPLE INPUT AND OUTPUT PORT TRANSFER INSTRUCTIONS:
¾IN
¾OUT
SPECIAL ADDRESS TRANSFER INSTRUCTIONS
¾LEA
¾LDS
¾LES
FLAG TRANSFER INSTRUCTIONS:
¾LAHF
¾SAHF
¾PUSHF
¾POPF
Arithmetic Instructions
ADITION INSTRUCTIONS:
¾ADD
¾ADC
¾INC
¾AAA
¾DAA
SUBTRACTION INSTRUCTIONS:
¾SUB
¾SBB
¾DEC
¾NEG
¾CMP
¾AAS
¾DAS
MULTIPLICATION INSTRUCTIONS:
¾MUL
¾IMUL
¾AAM
DIVISION INSTRUCTIONS:
¾DIV
¾IDIV
¾AAD
¾CBW
¾CWD
Bit Manipulation InstructionsLOGICAL INSTRUCTIONS:
¾NOT
¾AND
¾OR
¾XOR
¾TEST
SHIFT INSTRUCTIONS:
¾SHL / SAL
¾SHR
¾SAR
ROTATE INSTRUCTIONS:
¾ROL
¾ROR
¾RCL
¾RCR
String Instructions
¾REP
¾REPE / REPZ
¾REPNE / REPNZ
¾MOVS / MOVSB / MOVSW
¾COMPS / COMPSB / COMPSW
¾SCAS / SCASB / SCASW
¾LODS / LODSB / LODSW
¾STOS / STOSB / STOSW
Program Execution Transfer Instructions
UNCONDITIONAL TRANSFER INSTRUCTIONS:
¾CALL
¾RET
¾JMP
CONDITIONAL TRANSFER INSTRUCTIONS:
¾JA / JNBE
¾JAE / JNB
¾JB / JNAE
¾JBE / JNA
¾JC
¾JE / JZ
¾JG / JNLE
¾JGE / JNL
¾JL / JNGE
¾JLE / JNG
¾JNC
¾JNE / JNZ
AAA will adjust the result of the two ASCII characters that were in the range from 30h (“0”) to 39h(“9”).This is because the lower 4 bits of those character fall in the range of 0-9.The result of addition is not a ASCII character but it is a BCD digit. ¾Example: MOV AH, 0 ; Clear AH for MSD MOV AL, 6 ; BCD 6 in AL ADD AL, 5 ; Add BCD 5 to digit in AL AAA ; AH=1, AL=1 representing BCD 11. ¾AAD Instruction: ADD converts unpacked BCD digits in the AH and AL register into a single binary number in the AX register in preparation for a division operation. Before executing AAD, place the Most significant BCD digit in the AH register and Last significant in the AL register. When AAD is executed, the two BCD digits are combined into a single binary number by setting AL=(AH*10)+AL and clearing AH to 0. ¾Example: MOV AX, 0205h ; The unpacked BCD number 25 AAD ; After AAD, AH=0 and ; AL=19h (25) After the division AL will then contain the unpacked BCD quotient and AH will contain the unpacked BCD remainder. ¾Example: ; AX=0607 unpacked BCD for 67 decimal ; CH=09H AAD ; Adjust to binary before division ; AX=0043 = 43H =67 decimal DIV CH ; Divide AX by unpacked BCD in CH ; AL = quotient = 07 unpacked BCD ; AH = remainder = 04 unpacked BCD ¾AAM Instruction - AAM converts the result of the multiplication of two valid unpacked BCD digits into a valid 2-digit unpacked BCD number and takes AX as an implicit operand. To give a valid result the digits that have been multiplied must be in the range of 0 – 9 and the result should have been placed in the AX register. Because both operands of multiply are required to be 9 or less, the result must be less than 81 and thus is completely contained in AL. AAM unpacks the result by dividing AX by 10, placing the quotient (MSD) in AH and the remainder (LSD) in AL. ¾Example: MOV AL, 5 MOV BL, 7 MUL BL ; Multiply AL by BL, result in AX AAM ; After AAM, AX =0305h (BCD 35) ¾AAS Instruction: AAS converts the result of the subtraction of two valid unpacked BCD digits to a single valid BCD number and takes the AL register as an implicit operand. The two operands of the subtraction must have its lower 4 bit contain number in the range from 0 to 9.The AAS instruction then adjust AL so that it contain a correct BCD digit.
MOV AX, 0901H ; BCD 91
SUB AL, 9 ; Minus 9 AAS ; Give AX =0802 h (BCD 82)
( a )
; AL =0011 1001 =ASCII 9 ; BL=0011 0101 =ASCII 5 SUB AL, BL ; (9 - 5) Result: ; AL = 00000100 = BCD 04, CF = 0 AAS ; Result: ; AL=00000100 =BCD 04 ; CF = 0 NO Borrow required
( b ) ; AL = 0011 0101 =ASCII 5 ; BL = 0011 1001 = ASCII 9 SUB AL, BL ; ( 5 - 9 ) Result: ; AL = 1111 1100 = - 4 ; in 2’s complement CF = 1 AAS ; Results: ; AL = 0000 0100 =BCD 04 ; CF = 1 borrow needed. ¾ADD Instruction: These instructions add a number from source to a number from some destination and put the result in the specified destination. The add with carry instruction ADC, also add the status of the carry flag into the result. The source and destination must be of same type, means they must be a byte location or a word location. If you want to add a byte to a word, you must copy the byte to a word location and fill the upper byte of the word with zeroes before adding. ¾EXAMPLE: ADD AL, 74H ; Add immediate number 74H to content of AL ADC CL, BL ; Add contents of BL plus ; carry status to contents of CL. ; Results in CL ADD DX, BX ; Add contents of BX to contents ; of DX ADD DX, [SI] ; Add word from memory at ; offset [SI] in DS to contents of DX ; Addition of Un Signed numbers ADD CL, BL ; CL = 01110011 =115 decimal ; + BL = 01001111 = 79 decimal ; Result in CL = 11000010 = 194 decimal ; Addition of Signed numbers ADD CL, BL ; CL = 01110011 = + 115 decimal
saved on the stack is referred as the return address, because this is the address that execution will returns to after the procedure executes. A near CALL instruction will also load the instruction pointer with the offset of the first instruction in the procedure. A RET instruction at the end of the procedure will return execution to the instruction after the CALL by coping the offset saved on the stack back to IP. A Far CALL is a call to a procedure which is in a different from that which contains the CALL instruction. When 8086 executes the Far CALL instruction it decrements the stack pointer by two again and copies the content of CS register to the stack. It then decrements the stack pointer by two again and copies the offset contents offset of the instruction after the CALL to the stack. Finally it loads CS with segment base of the segment which contains the procedure and IP with the offset of the first instruction of the procedure in segment. A RET instruction at end of procedure will return to the next instruction after the CALL by restoring the saved CS and IP from the stack. ; Direct within-segment (near or intrasegment ) CALL MULTO ; MULTO is the name of the procedure. The assembler determines displacement of MULTO from the instruction after the CALL and codes this displacement in as part of the instruction. ; Indirect within-segment ( near or intrasegment ) CALL BX ; BX contains the offset of the first instruction of the procedure. Replaces contents of word of IP with contents o register BX. CALL WORD PTR [BX] ; Offset of first instruction of procedure is in two memory addresses in DS. Replaces contents of IP with contents of word memory location in DS pointed to by BX. ; Direct to another segment- far or intersegment. CALL SMART ; SMART is the name of the Procedure SMART PROC FAR; Procedure must be declare as an far ¾CBW Instruction - CBW converts the signed value in the AL register into an equivalent 16 bit signed value in the AX register by duplicating the sign bit to the left. This instruction copies the sign of a byte in AL to all the bits in AH. AH is then said to be the sign extension of AL. Example: ; AX = 00000000 10011011 = - 155 decimal CBW ; Convert signed byte in AL to signed word in AX. ; Result in AX = 11111111 10011011 ; = - 155 decimal ¾CLC Instruction: CLC clear the carry flag (CF) to 0 This instruction has no affect on the processor, registers, or other flags. It is often used to clear the CF before returning from a procedure to indicate a successful termination. It is also use to clear the CF during rotate operation involving the CF such as ADC, RCL, RCR. Example: CLC ; Clear carry flag. ¾CLD Instruction: This instruction reset the designation flag to zero. This instruction has no effect on the registers or other flags. When the direction flag is cleared / reset SI and DI will
automatically be incremented when one of the string instruction such as MOVS, CMPS, SCAS, MOVSB and STOSB executes. Example: CLD ; Clear direction flag so that string pointers auto increment ¾CLI Instruction: This instruction resets the interrupt flag to zero. No other flags are affected. If the interrupt flag is reset, the 8086 will not respond to an interrupt signal on its INTR input. This CLI instruction has no effect on the nonmaskable interrupt input, NMI ¾CMC Instruction: If the carry flag CF is a zero before this instruction, it will be set to a one after the instruction. If the carry flag is one before this instruction, it will be reset to a zero after the instruction executes. CMC has no effect on other flags. Example: CMC; Invert the carry flag. ¾CWD Instruction: CWD converts the 16 bit signed value in the AX register into an equivalent 32 bit signed value in DX: AX register pair by duplicating the sign bit to the left. The CWD instruction sets all the bits in the DX register to the same sign bit of the AX register. The effect is to create a 32- bit signed result that has same integer value as the original 16 bit operand. Example: Assume AX contains C435h. If the CWD instruction is executed, DX will contain FFFFh since bit 15 (MSB) of AX was 1. Both the original value of AX (C435h) and resulting value of DX: AX (FFFFC435h) represents the same signed number. Example: ; DX = 00000000 00000000 ; AX = 11110000 11000111 = - 3897 decimal CWD ; Convert signed word in AX to signed double ; word in DX:AX ; Result DX = 11111111 11111111 ; AX = 11110000 11000111 = -3897 decimal. ¾DAA Instruction - Decimal Adjust Accumulator ¾DAS Instruction - Decimal Adjust after Subtraction ¾DEC Instruction - Decrement destination register or memory DEC destination. ¾DIV Instruction - Unsigned divide-Div source ¾ESC Instruction When a double word is divided by a word, the most significant word of the double word must be in DX and the least significant word of the double word must be in AX. After the division AX will contain the 16 –bit result (quotient) and DX will contain a 16 bit remainder. Again, if an attempt is made to divide by zero or quotient is too large to fit in AX (greater than FFFFH) the 8086 will do a type of 0 interrupt. Example: DIV CX ; (Quotient) AX= (DX: AX)/CX : (Reminder) DX= (DX: AX)%CX
IMUL BL ; AX = 03C6H = + 966 decimal ; MSB = 0 because positive result
; - 28 * 59 ; AL = 11100100 = - 28 decimal ; BL = 00001110 = 14 decimal IMUL BL ; AX = F98Ch = - 1652 decimal ; MSB = 1 because negative result ¾IN Instruction: This IN instruction will copy data from a port to the AL or AX register. For the Fixed port IN instruction type the 8 – bit port address of a port is specified directly in the instruction. ¾Example: IN AL, 0C8H ; Input a byte from port 0C8H to AL IN AX, 34H ; Input a word from port 34H to AX A_TO_D EQU 4AH IN AX, A_TO_D ; Input a word from port 4AH to AX For a variable port IN instruction, the port address is loaded in DX register before IN instruction. DX is 16 bit. Port address range from 0000H – FFFFH. ¾Example: MOV DX, 0FF78H ; Initialize DX point to port IN AL, DX ; Input a byte from a 8 bit port ; 0FF78H to AL IN AX, DX ; Input a word from 16 bit port to ; 0FF78H to AX. ¾INC Instruction: INC instruction adds one to the operand and sets the flag according to the result. INC instruction is treated as an unsigned binary number. ¾Example: ; AX = 7FFFh INC AX ; After this instruction AX = 8000h INC BL ; Add 1 to the contents of BL register INC CL ; Add 1 to the contents of CX register. ¾INT Instruction - Interrupt program ¾INTO Instruction - Interrupt on overflow. ¾IRET Instruction - Interrupt return ¾JA/JNBE Instruction - Jump if above/Jump if not below nor equal. ¾JAE/JNB/JNC Instructions- Jump if above or equal/ Jump if not below/ Jump if no carry. ¾JA / JNBE - This instruction performs the Jump if above (or) Jump if not below or equal operations according to the condition, if CF and ZF = 0. ¾Example: ( 1 )
CMP AX, 4371H ; Compare by subtracting 4371H ; from AX
JA RUN_PRESS ; Jump to label RUN_PRESS if ; AX above 4371H ( 2 ) CMP AX, 4371H ; Compare ( AX – 4371H) JNBE RUN_PRESS ; Jump to label RUN_PRESS if ; AX not below or equal to 4371H ¾JAE / JNB / JNC - This instructions performs the Jump if above or equal, Jump if not below, Jump if no carry operations according to the condition, if CF = 0. ¾Examples:
CMP AX, 4371H ; Compare ( AX – 4371H) JAE RUN ; Jump to the label RUN if AX is ; above or equal to 4371H.
CMP AX, 4371H ; Compare ( AX – 4371H) JNB RUN_1 ; Jump to the label RUN_1 if AX ; is not below than 4371H
ADD AL, BL ; Add AL, BL. If result is with in JNC OK ; acceptable range, continue ¾JB/JC/JNAE Instruction - Jump if below/Jump if carry/ Jump if not above nor equal ¾JBE/JNA Instructions- Jump if below or equal / Jump if not above ¾JCXZ Instruction - Jump if the CX register is zero ¾JE/JZ Instruction - Jump if equal/Jump if zero ¾JG/JNLE Instruction- Jump if greater/Jump if not less than nor equal ¾JB/JC/JNAE Instruction - This instruction performs the Jump if below (or) Jump if carry (or) Jump if not below/ equal operations according to the condition, if CF = 1 ¾Example:
CMP AX, 4371H ; Compare (AX – 4371H) JB RUN_P ; Jump to label RUN_P if AX is ; below 4371H
ADD BX, CX ; Add two words and Jump to JC ERROR ; label ERROR if CF = 1 ¾JBE/JNA Instruction - This instruction performs the Jump if below or equal (or) Jump if not above operations according to the condition, if CF and ZF = 1 ¾Example: CMP AX, 4371H ; Compare (AX – 4371H ) JBA RUN ; Jump to label RUN if AX is ; below or equal to 4371H CMP AX, 4371H ; Compare ( AX – 4371H ) JNA RUN_R ; Jump to label RUN_R if AX is ; not above than 4371H ¾JCXZ Instruction:
CMP BL, 39H ; Compare by the ; subtracting 39H from BL JGE NEXT11 ; Jump to label if BL is ; more positive than 39H ; or equal to 39H CMP BL, 39H ; Compare by subtracting ; 39H from BL JNL NEXT22 ; Jump to label if BL is not ; less than 39H ¾JL/JNGE Instruction - This instruction performs the Jump if less than / Jump if not greater than or equal operation according to the condition, if SF ≠ OF ¾Example: CMP BL, 39H ; Compare by subtracting 39H ; from BL JL AGAIN ; Jump to the label if BL is more ; negative than 39H CMP BL, 39H ; Compare by subtracting 39H ; from BL JNGE AGAIN1 ; Jump to the label if BL is not ; more positive than 39H or ; not equal to 39H ¾JLE/JNG Instruction - This instruction performs the Jump if less than or equal / Jump if not greater operation according to the condition, if ZF=1 and SF ≠ OF ¾Example: CMP BL, 39h ; Compare by subtracting 39h ; from BL JLE NXT1 ; Jump to the label if BL is more ; negative than 39h or equal to 39h CMP BL, 39h ; Compare by subtracting 39h ; from BL JNG AGAIN2 ; Jump to the label if BL is not ; more positive than 39h ¾JNA/JBE Instruction - Jump if not above/Jump if below or equal ¾JNAE/JB Instruction - Jump if not above or equal/ Jump if below ¾JNB/JNC/JAE Instruction - Jump if not below/Jump if no carry/Jump if above or equal ¾JNE/JNZ Instruction - Jump if not equal/Jump if not zero ¾JNE/JNZ Instruction - This instruction performs the Jump if not equal / Jump if not zero operation according to the condition, if ZF= ¾Example:
NXT: IN AL, 0F8H ; Read data value from port CMP AL, 72 ; Compare ( AL – 72 )
JNE NXT ; Jump to NXT if AL ≠ 72 IN AL, 0F9H ; Read next port when AL = 72 MOV BX, 2734H ; Load BX as counter NXT_1: ADD AX, 0002H ; Add count factor to AX DEC BX ; Decrement BX JNZ NXT_1 ; Repeat until BX = 0 ¾JNG/JLE Instruction - Jump if not greater/ Jump if less than or equal ¾JNGE/JL Instruction - Jump if not greater than nor equal/Jump if less than ¾JNL/JGE Instruction - Jump if not less than/ Jump if greater than or equal ¾JNLE/JG Instruction - Jump if not less than nor equal to /Jump if greater than ¾JNO Instruction – Jump if no overflow ¾JNP/JPO Instruction – Jump if no parity/ Jump if parity odd ¾JNS Instruction - Jump if not signed (Jump if positive) ¾JNZ/JNE Instruction - Jump if not zero / jump if not equal ¾JO Instruction - Jump if overflow ¾JNO Instruction – This instruction performs the Jump if no overflow operation according to the condition, if OF= ¾Example: ADD AL, BL ; Add signed bytes in AL and BL JNO DONE ; Process done if no overflow - MOV AL, 00H ; Else load error code in AL DONE: OUT 24H, AL ; Send result to display ¾JNP/JPO Instruction – This instruction performs the Jump if not parity / Jump if parity odd operation according to the condition, if PF= ¾Example: IN AL, 0F8H ; Read ASCII char from UART OR AL, AL ; Set flags JPO ERROR1 ; If even parity executed, if not ; send error message ¾JNS Instruction - This instruction performs the Jump if not signed (Jump if positive) operation according to the condition, if SF= ¾Example: DEC AL ; Decrement counter JNS REDO ; Jump to label REDO if counter has not ; decremented to FFH ¾JO Instruction - This instruction performs Jump if overflow operation according to the condition OF = 0 ¾Example: ADD AL, BL ; Add signed bits in AL and BL JO ERROR ; Jump to label if overflow occur ; in addition
¾Example: LEA BX, PRICE ; Load BX with offset of PRICE ; in DS LEA BP, SS:STAK ; Load BP with offset of STACK ; in SS LEA CX, [BX][DI] ; Load CX with EA=BX + DI ¾LOCK Instruction - Assert bus lock signal ¾LODS/LODSB/ LODSW Instruction - Load string byte into AL or Load string word into AX. ¾LOOP Instruction - Loop to specified label until CX = 0 ¾LOOPE / LOOPZ Instruction - loop while CX ≠ 0 and ZF = 1 ¾LODS/LODSB/LODSW Instruction - This instruction copies a byte from a string location pointed to by SI to AL or a word from a string location pointed to by SI to AX. If DF is cleared to 0, SI will automatically incremented to point to the next element of string. ¾Example: CLD ; Clear direction flag so SI is auto incremented MOV SI, OFFSET SOURCE_STRING ; point SI at start of the string LODS SOUCE_STRING ; Copy byte or word from ; string to AL or AX ¾LOOP Instruction - This instruction is used to repeat a series of instruction some number of times ¾Example: MOV BX, OFFSET PRICE ; Point BX at first element in array MOV CX, 40 ; Load CX with number of ; elements in array NEXT: MOV AL, [BX] ; Get elements from array ADD AL, 07H ; Ad correction factor DAA ; decimal adjust result MOV [BX], AL ; Put result back in array LOOP NEXT ; Repeat until all elements ; adjusted. ¾LOOPE / LOOPZ Instruction - This instruction is used to repeat a group of instruction some number of times until CX = 0 and ZF = 0 ¾Example: MOV BX, OFFSET ARRAY ; point BX at start of the array DEC BX MOV CX, 100 ; put number of array elements in ; CX NEXT:INC BX ; point to next element in array
CMP [BX], 0FFH ; Compare array elements FFH LOOP NEXT ¾LOOPNE/LOOPNZ Instruction - This instruction is used to repeat a group of instruction some number of times until CX = 0 and ZF = 1 ¾Example: MOV BX, OFFSET ARRAY ; point BX at start of the array DEC BX MOV CX, 100 ; put number of array elements in ; CX NEXT:INC BX ; point to next elements in array CMP [BX], 0FFH ; Compare array elements 0DH LOOPNE NEXT ¾MOV Instruction - MOV destination, source ¾MOVS/MOVSB/ MOVSW Instruction - Move string byte or string word-MOVS destination, source ¾MUL Instruction - Multiply unsigned bytes or words-MUL source ¾NEG Instruction - From 2’s complement – NEG destination ¾NOP Instruction - Performs no operation. ¾MOV Instruction - The MOV instruction copies a word or a byte of data from a specified source to a specified destination. MOV op1, op ¾Example: MOV CX, 037AH ; MOV 037AH into the CX. MOV AX, BX ; Copy the contents of register BX ; to AX MOV DL, [BX] ; Copy byte from memory at BX ; to DL, BX contains the offset of byte in DS. ¾MUL Instruction: This instruction multiplies an unsigned multiplication of the accumulator by the operand specified by op. The size of op may be a register or memory operand. MUL op Example: ; AL = 21h (33 decimal) ; BL = A1h(161 decimal ) MUL BL ; AX =14C1h (5313 decimal) since AH ≠ 0, ; CF and OF will set to 1. MUL BH ; AL times BH, result in AX MUL CX ; AX times CX, result high word in DX, ; low word in AX. ¾NEG Instruction - NEG performs the two’s complement subtraction of the operand from zero and sets the flags according to the result. ; AX = 2CBh NEG AX ; after executing NEG result AX =FD35h.
OUT DX, AX ; Copy content of AX to port ; FFF8H ¾POP Instruction: POP instruction copies the word at the current top of the stack to the operand specified by op then increments the stack pointer to point to the next stack. ¾Example: POP DX ; Copy a word from top of the stack to ; DX and increments SP by 2. POP DS ; Copy a word from top of the stack to ; DS and increments SP by 2. POP TABLE [BX] ; Copy a word from top of stack to memory in DS with ; EA = TABLE + [BX]. ¾POPF Instruction - Pop word from top of stack to flag - register. ¾PUSH Instruction - PUSH source ¾PUSHF Instruction - Push flag register on the stack ¾RCL Instruction - Rotate operand around to the left through CF – RCL destination, source. ¾ RCR Instruction - Rotate operand around to the right through CF- RCR destination, count ¾POPF Instruction - This instruction copies a word from the two memory location at the top of the stack to flag register and increments the stack pointer by 2. ¾PUSH Instruction: PUSH instruction decrements the stack pointer by 2 and copies a word from a specified source to the location in the stack segment where the stack pointer pointes. ¾Example: PUSH BX ; Decrement SP by 2 and copy BX to stack PUSH DS ; Decrement SP by 2 and copy DS to stack PUSH TABLE[BX] ; Decrement SP by 2 and copy word ; from memory in DS at ; EA = TABLE + [BX] to stack. ¾PUSHF Instruction: This instruction decrements the SP by 2 and copies the word in flag register to the memory location pointed to by SP. ¾RCL Instruction: RCL instruction rotates the bits in the operand specified by op1 towards left by the count specified in op2.The operation is circular, the MSB of operand is rotated into a carry flag and the bit in the CF is rotated around into the LSB of operand. RCR op1, op ¾Example: CLC ; put 0 in CF RCL AX, 1 ; save higher-order bit of AX in CF RCL DX, 1 ; save higher-order bit of DX in CF ADC AX, 0 ; set lower order bit if needed. ¾Example:
RCL DX, 1 ; Word in DX of 1 bit is moved to left, and ; MSB of word is given to CF and ; CF to LSB. ; CF=0, BH = 10110011 RCL BH, 1 ; Result: BH = ; CF = 1, OF = 1 because MSB changed ; CF =1, AX =00011111 10101001 MOV CL, 2 ; Load CL for rotating 2 bit position RCL AX, CL ; Result: CF =0, OF undefined ; AX = 01111110 10100110 ¾RCR Instruction - RCR instruction rotates the bits in the operand specified by op1 towards right by the count specified in op2. RCR op1, op ¾Example: ( 1) RCR BX, 1 ; Word in BX is rotated by 1 bit towards ; right and CF will contain MSB bit and ; LSB contain CF bit. ( 2) ; CF = 1, BL = 00111000 RCR BL, 1 ; Result: BL = 10011100, CF = ; OF = 1 because MSB is changed to 1. ¾REP/REPE/REPZ/ REPNE/REPNZ - (Prefix) Repeat String instruction until specified condition exist ¾RET Instruction – Return execution from procedure to calling program. ¾ROL Instruction - Rotate all bits of operand left, MSB to LSB ROL destination, count. ¾ROL Instruction - ROL instruction rotates the bits in the operand specified by op1 towards left by the count specified in op2. ROL moves each bit in the operand to next higher bit position. The higher order bit is moved to lower order position. Last bit rotated is copied into carry flag. ROL op1, op ¾Example: ( 1 ) ROL AX, 1 ; Word in AX is moved to left by 1 bit ; and MSB bit is to LSB, and CF ; CF =0, BH = ROL BH, 1 ; Result: CF, Of =1, BH = 01011101 ¾Example: ( 2 ) ; BX = 01011100 11010011 ; CL = 8 bits to rotate ROL BH, CL ; Rotate BX 8 bits towards left ; CF =0, BX =11010011 01011100 ¾ROR Instruction - Rotate all bits of operand right, LSB to MSB – ROR destination, count ¾SAHF Instruction – Copy AH register to low byte of flag register
