ADD Instruction ADD destination,source

destination = destination + source

ADD AX,BX ADD SUM,EAX ADD EDX,ARRAY[EBX][ESI] ADD CL,5 ADD DL,[BX]

ADC Instruction ADC destination,source

destination = destination + source + carry

ADC DX,BX ADC COUNT,ECX ADC EAX,ARRAY[EBX][ESI]

XADD Instruction XADD destination,source

destination = destination + source Source = original destination

Assume: BX = 0AH DX = 11H

After XADD BX,DX is executed: BX = 1BH DX = 0AH

80486 and Pentium instruction.

INC Instruction INC operand

operand = operand + 1

INC BX INC COUNT INC DWORD PTR [EBX]

SUB Instruction SUB destination,source

destination = destination - source

SUB AX,BX SUB SUM,EAX SUB EDX,ARRAY[EBX][ESI] SUB CL,5 SUB DL,[BX]

SBB Instruction SBB destination,source

destination = destination - source - carry

SBB DX,BX SBB COUNT,ECX SBB EAX,ARRAY[EBX][ESI]

DEC Instruction DEC operand

operand = operand - 1

DEC BX DEC COUNT DEC DWORD PTR [EBX]

CMP Instruction CMP operand1,operand2

operand1 - operand2 Flags are updated and the result is discarded.

CMP AL,BL CMP BX,0ABCH CMP DL,[BX]

CMPXCHG Instruction CMPXCHG operand1,operand2

If operand1 = accumulator then accumulator = operand2

Else accumulator = operand1

CMPXCHG BL,CL CMPXCHG DATA,EDX

CMPXCHG8B allows the comparison of quad words

MUL and IMUL Instructions MUL operand (unsigned product) IMUL operand (signed product)

accumulator = accumulator * operand

MUL BL AX = AL * BL

MUL CX <DX>:<AX> = AX * CX

MUL EBX <EDX>:<EAX> = EAX * EBX

MUL and IMUL Instructions MUL BYTE PTR TEMP

AX = AL * TEMP MUL WORD PTR [DI]

<DX>:<AX> = AX * [DI] MUL DWORD PTR [EBX]

<EDX>:<EAX> = EAX * [EBX]

Special Immediate 16 bit Product IMUL reg,imm IMUL reg,reg,imm IMUL reg,mem,imm

IMUL CX,16 CX = CX * 16

IMUL DX,DATA,2 DX = DATA * 2

DIV and IDIV Instructions DIV operand (unsigned division) IDIV operand (signed division) DIV BL

AL (quotient) = AX / BL AH (remainder) = AX / BL

DIV CX AX (quotient) = <DX>:<AX> / CX DX (remainder) = <DX>:<AX> / CX

DIV and IDIV Instructions DIV EBX

EAX (quotient) = <EDX>:<EAX> / EBX EDX (remainder) = <EDX>:<EAX> / EBX

DIV BYTE PTR TEMP DIV WORD PTR [DI] DIV DWORD PTR [EBX]

BCD Arithmetic Instructions that use packed BCD

operands. DAA - Decimal adjust after addition. DAS - Decimal adjust after subtraction.

MOV BL,14H MOV AL,47H ADD AL,BL DAA

ASCII Arithmetic Instructions that use unpacked BCD operands. AAM – Adjust after multiplication.

MOV AL,5 MOV BL,8 MUL BL AAM

AAD – Adjust before division. MOV AL,12 MOV BL,3 AAD DIV BL

ASCII Arithmetic Instructions that use ASCII operands. AAA – Adjust after addition. AAS – Adjust after subtraction.

MOX AX,31H ADD AL,39H AAA ADD AX,3030H

AND Instruction

AND destination,source destination = destination ∙ source

AND AX,BX AND SUM,EAX AND EDX,ARRAY[EBX][ESI] AND CL,5 AND DL,[BX]

OR Instruction

OR destination,source destination = destination + source

OR AX,BX OR SUM,EAX OR EDX,ARRAY[EBX][ESI] OR CL,5 OR DL,[BX]

XOR Instruction

XOR destination,source destination = destination source⊕

XOR AX,BX XOR SUM,EAX XOR EDX,ARRAY[EBX][ESI] XOR CL,5 XOR DL,[BX]

NOT and NEG Instructions NOT operand – 1’s complement NEG operand – 2’s complement

operand = operand’

NOT BX NEG SUM NOT ECX NEG CL

TEST Instruction TEST operand1, operand2

operand1 ∙ operand2 Flags are updated and the result is discarded.

TEST AX,BX TEST SUM,EAX TEST CL,5 TEST DL,[BX]

Shift Instructions These instructions

perform the logical and arithmetic shifts.

SHL destination,count SAL destination,count SHR destination,count SAR destination,count

Count can be an immediate value or the CX register. SHL AX,CX SAR DL,1

Rotate Instructions These instructions

perform the logical and arithmetic shifts.

RCL destination,count ROL destination,count RCR destination,count ROR destination,count

Count can be an immediate value or the CX register. ROL EDX,16 RCR BH,CL

Conditional Transfers These instructions conditionally modify

the EIP register to be one of two addresses defined as follows: An address or displacement following the

instruction (label); The address of the instruction following the

conditional jump. Ex:

JE SUM SUB EAX,EBX . . SUM:

Conditional Transfers Used with unsigned integers

JA/JNBE – Jump if above – Z=0 and C=0 JAE/JNB – Jump if above or equal – C=0 JB/JNA – Jump if below – C=1 JBE/JNA – Jump if below or equal – Z=1 and C=1

CMP AL,BL JA NEXT MOV CL,0 . . NEXT:

Conditional Transfers Used with signed integers

JG/JNLE – Jump if greater – Z=0 and S=0 JGE/JNL – Jump if greater or equal – S=0 JL/JNGE – Jump if less – S<>0 JLE/JNG – Jump if less or equal – Z=1 and S<>0

CMP AL,BL JLE NEXT MOV CL,0 . . NEXT:

Conditional Transfers Other conditions

JE/JZ – Jump if equal – Z=1 JNE/JNZ – Jump if not equal – Z=0 JC – Jump if carry - C=1 JNC – Jump if not carry – C=0 JS – Jump if sign – S=1 JNS – Jump if not sign – S=0 JO – Jump if overflow – O=1 JNO – Jump if not overflow – O=0

Conditional Transfers JP/JPE – Jump if parity/parity even – P=1 JNP/JPO – Jump if not parity/parity odd – P=0 JCXZ – Jump if CX is zero JECXZ – Jump if ECX is zero

Conditional Set The 80386 and above processors have

conditional set instructions. These instructions set a byte to 01H or 00H depending on the value of the flag or condition under test.

Example: SETZ COUNT_ZERO

Conditional Set Used with unsigned integers

SETA – Set if above – Z=0 and C=0 SETAE – Set if above or equal – C=0 SETB – Set if below – C=1 SETBE – Set if below or equal – Z=1 and C=1

Used with signed integers SETG – Set if greater – Z=0 and S=0 SETGE – Set if greater or equal – S=0 SETL – Set if less – S<>0 SETLE – Set if less or equal – Z=1 and S<>0

Conditional Set Other conditions

SETE/SETZ – Set if equal – Z=1 SETNE/SETNZ – Set if not equal – Z=0 SETC – Set if carry - C=1 SETNC – Set if not carry – C=0 SETS – Set if sign – S=1 SETNS – Set if not sign – S=0 SETO – Set if overflow – O=1 SETNO – Set if not overflow – O=0

Conditional Set SETP/JPE – Set if parity/parity even – P=1 SETNP/SETPO – Set if not parity/parity odd – P=0

Controlling the Flow of the Program Using Dot Commands Dot commands are available for MASM

version 6.xx and above. They do not work with Visual C++ inline

assembler. When these directives are found the

assembler inserts the appropriate instructions that will perform what the directives indicate.

Controlling the Flow of the Program Using Dot Commands Commands:

.IF, .ELSE, .ELSEIF, and .ENDIF .WHILE, .BREAK, .CONTINUE and .ENDW .REPEAT, .UNTIL, and .UNTILCXZ

.IF, .ELSE, .ELSEIF, and .ENDIF Relational operators

used with .IF statements

Operator Function== Equal!= Not equal> Greater than

>= Greater than or equal< Less than

<= Less than or equal& Bit test! Logical inversion

&& Logical AND|| Logical OR| OR

.IF, .ELSE, .ELSEIF, and .ENDIF INC BL .IF BL >= 205 || BL<= 2 ADD BL,CL .ENDIF MOV DX,1

INC BL .IF BL >= 205 || BL<= 2 CMP BL,205 JAE @C001 CMP BL,2 JA @C002 @C001: ADD BL,CL .ENDIF @C002: MOV DX,1

.WHILE, .BREAK, .CONTINUE and .ENDW The .BREAK statement allows for

unconditional exit from loop. The .BREAK statement may be followed

by an .IF statement thus allowing for conditional exit from the loop.

The .CONTINUE statement behaves in the reverse way as the .BREAK statement. It is always conditional.

.WHILE, .BREAK, .CONTINUE and .ENDW .WHILE BL >= 1 MOV BL, DATA[SI] MOV COPY[SI],BL INC SI .ENDW MOV AX,DX

.WHILE BL >= 1 JMP @C001 @C002: MOV BL, DATA[SI] MOV COPY[SI],BL INC SI .ENDW @C001: CMP BL,1 JAE @C002 MOV AX,DX

Procedures Also known as subroutines, these sets of

instructions usually perform a single task. They are reusable code, that can be

executed as often as needed by calling it. Procedures save memory, but the calling

of a procedure takes a small amount of time.

Procedures Format

Name PROC [NEAR or FAR] Subroutine code RET

ENDP

Global procedures are defined as FAR. Local procedures are defined as NEAR.

Procedures CALL destination

Calls a subroutine at location destination. Different addressing modes may be used for

destination. CALL DELAY CALL EBX CALL ARRAY[BX]

RET Returns execution of program to location

stored in stack. NEAR or FAR is dependent on procedure

definition.

Interrupts INT type INTO – Interrupt if overflow IRET These instructions modify the EIP register to

be the address stored at: The IDT. The interrupt type or number is used to

identify which element of the IDT holds the addresses of the desired interrupt service subroutines;

The stack. The address stored in the stack by the INT or INTO instruction. This address identifies the return point after the interrupts execution.

Miscellaneous Control Instructions WAIT – Delays the execution of the

program conditionally to the BUSY’ pin. HLT – It stops execution of software.

There are three way to exit a halt instruction: Interrupt; Hardware reset; DMA operation.

NOP – No operation. LOCK’ Prefix – Causes LOCK’ pin to

become logic 0.

Miscellaneous Control Instructions ESC – Passes information to the

numerical co-processor. BOUND – Comparison that may generate

an interrupt call. The comparison is between the contents of two words or double words, an upper and a lower boundary.

ENTER and LEAVE – Allow the creation and use of stack frames.