Assembler language Instructions
A D V E R T I S E M E N T
- Transfer instructions
- Loading instructions
- Stack instructions
- Logic instructions
- Arithmetic instructions
Transfer instructions
They are used to move the contents of the operators. Each instruction can be
used with different modes of addressing.
MOV
MOVS (MOVSB) (MOVSW)
MOV INSTRUCTION
Purpose: Data transfer between memory cells, registers and the accumulator.
Syntax:
MOV Destiny, Source
Where Destiny is the place where the data will be moved and Source is the
place where the data is.
The different movements of data allowed for this instruction are:
*Destiny: memory. Source: accumulator
*Destiny: accumulator. Source: memory
*Destiny: segment register. Source: memory/register
*Destiny: memory/register. Source: segment register
*Destiny: register. Source: register
*Destiny: register. Source: memory
*Destiny: memory. Source: register
*Destiny: register. Source: immediate data
*Destiny: memory. Source: immediate data
Example:
MOV AX,0006h
MOV BX,AX
MOV AX,4C00h
INT 21H
This small program moves the value of 0006H to the AX register, then it moves
the content of AX (0006h) to the BX register, and lastly it moves the 4C00h
value to the AX register to end the execution with the 4C option of the 21h
interruption.
MOVS (MOVSB) (MOVSW) Instruction
Purpose: To move byte or word chains from the source, addressed by SI, to the
destiny addressed by DI.
Syntax:
MOVS
This command does not need parameters since it takes as source address the
content of the SI register and as destination the content of DI. The following
sequence of instructions illustrates this:
MOV SI, OFFSET VAR1
MOV DI, OFFSET VAR2
MOVS
First we initialize the values of SI and DI with the addresses of the VAR1
and VAR2 variables respectively, then after executing MOVS the content of VAR1
is copied onto VAR2.
The MOVSB and MOVSW are used in the same way as MOVS, the first one moves one
byte and the second one moves a word.
Loading instructions
They are specific register instructions. They are used to load bytes or
chains of bytes onto a register.
LODS (LODSB) (LODSW)
LAHF
LDS
LEA
LES
LODS (LODSB) (LODSW) INSTRUCTION
Purpose: To load chains of a byte or a word into the accumulator.
Syntax:
LODS
This instruction takes the chain found on the address specified by SI, loads
it to the AL (or AX) register and adds or subtracts , depending on the state of
DF, to SI if it is a bytes transfer or if it is a words transfer.
MOV SI, OFFSET VAR1
LODS
The first line loads the VAR1 address on SI and the second line takes the
content of that locality to the AL register.
The LODSB and LODSW commands are used in the same way, the first one loads a
byte and the second one a word (it uses the complete AX register).
LAHF INSTRUCTION
Purpose: It transfers the content of the flags to the AH register.
Syntax:
LAHF
This instruction is useful to verify the state of the flags during the
execution of our program.
The flags are left in the following order inside the register:
SF ZF ?? AF ?? PF ?? CF
LDS INSTRUCTION
Purpose: To load the register of the data segment
Syntax:
LDS destiny, source
The source operator must be a double word in memory. The word associated with
the largest address is transferred to DS, in other words it is taken as the
segment address. The word associated with the smaller address is the
displacement address and it is deposited in the register indicated as destiny.
LEA INSTRUCTION
Purpose: To load the address of the source operator
Syntax:
LEA destiny, source
The source operator must be located in memory, and its displacement is placed
on the index register or specified pointer in destiny.
To illustrate one of the facilities we have with this command let us write an
equivalence:
MOV SI,OFFSET VAR1
Is equivalent to:
LEA SI,VAR1
It is very probable that for the programmer it is much easier to create
extensive programs by using this last format.
LES INSTRUCTION
Purpose: To load the register of the extra segment
Syntax:
LES destiny, source
The source operator must be a double word operator in memory. The content of
the word with the larger address is interpreted as the segment address and it is
placed in ES. The word with the smaller address is the displacement address and
it is placed in the specified register on the destiny parameter.
Stack instructions
These instructions allow the use of the stack to store or retrieve data.
POP
POPF
PUSH
PUSHF
POP INSTRUCTION
Purpose: It recovers a piece of information from the stack
Syntax:
POP destiny
This instruction transfers the last value stored on the stack to the destiny
operator, it then increases by 2 the SP register. This increase is due to the
fact that the stack grows from the highest memory segment address to the lowest,
and the stack only works with words, 2 bytes, so then by increasing by two the
SP register, in reality two are being subtracted from the real size of the
stack.
POPF INSTRUCTION
Purpose: It extracts the flags stored on the stack
Syntax:
POPF
This command transfers bits of the word stored on the higher part of the
stack to the flag register.
The way of transference is as follows:
BIT FLAG
0 CF
2 PF
4 AF
6 ZF
7 SF
8 TF
9 IF
10 DF
11 OF
These localities are the same for the PUSHF command.
Once the transference is done the SP register is increased by 2,
diminishing the size of the stack.
PUSH INSTRUCTION
Purpose: It places a word on the stack.
Syntax:
PUSH source
The PUSH instruction decreases by two the value of SP and then transfers the
content of the source operator to the new resulting address on the recently
modified register.
The decrease on the address is due to the fact that when adding values to the
stack, this one grows from the greater to the smaller segment address, therefore
by subtracting 2 from the SP register what we do is to increase the size of the
stack by two bytes, which is the only quantity of information the stack can
handle on each input and output of information.
PUSHF INSTRUCTION
Purpose: It places the value of the flags on the stack.
Syntax:
PUSHF
This command decreases by 2 the value of the SP register and then the content
of the flag register is transferred to the stack, on the address indicated by
SP.
The flags are left stored in memory on the same bits indicated on the POPF
command.
Logic instructions
They are used to perform logic operations on the operators.
AND
NEG
NOT
OR
TEST
XOR
AND INSTRUCTION
Purpose: It performs the conjunction of the operators bit by bit.
Syntax:
AND destiny, source
With this instruction the "y" logic operation for both operators is carried
out:
Source Destiny | Destiny
-----------------------------
1 1 | 1
1 0 | 0
0 1 | 0
0 0 | 0
The result of this operation is stored on the destiny operator.
NEG INSTRUCTION
Purpose: It generates the complement to 2.
Syntax:
NEG destiny
This instruction generates the complement to 2 of the destiny operator and
stores it on the same operator.
For example, if AX stores the value of 1234H, then:
NEG AX
This would leave the EDCCH value stored on the AX register.
NOT INSTRUCTION
Purpose: It carries out the negation of the destiny operator bit by bit.
Syntax:
NOT destiny
The result is stored on the same destiny operator.
OR INSTRUCTION
Purpose: Logic inclusive OR
Syntax:
OR destiny, source
The OR instruction carries out, bit by bit, the logic inclusive disjunction
of the two operators:
Source Destiny | Destiny
-----------------------------------
1 1 | 1
1 0 | 1
0 1 | 1
0 0 | 0
TEST INSTRUCTION
Purpose: It logically compares the operators
Syntax:
TEST destiny, source
It performs a conjunction, bit by bit, of the operators, but differing from
AND, this instruction does not place the result on the destiny operator, it only
has effect on the state of the flags.
XOR INSTRUCTION
Purpose: OR exclusive
Syntax:
XOR destiny, source Its function is to perform the logic exclusive
disjunction of the two operators bit by bit.
Source Destiny | Destiny
-----------------------------------
1 1 | 0
0 0 | 1
0 1 | 1
0 0 | 0
Arithmetic instructions
They are used to perform
arithmetic operations on the
operators.
ADC
ADD
DIV
IDIV
MUL
IMUL
SBB
SUB
ADC INSTRUCTION
Purpose: Cartage addition
Syntax:
ADC destiny, source
It carries out the addition of two operators and adds one to the result in
case the CF flag is activated, this is in case there is carried.
The result is stored on the destiny operator.
ADD INSTRUCTION
Purpose: Addition of the operators.
Syntax:
ADD destiny, source
It adds the two operators and stores the result on the destiny operator.
DIV INSTRUCTION
Purpose: Division without sign.
Syntax:
DIV source
The divider can be a byte or a word and it is the operator which is given the
instruction.
If the divider is 8 bits, the 16 bits AX register is taken as dividend and if
the divider is 16 bits the even DX:AX register will be taken as dividend, taking
the DX high word and AX as the low.
If the divider was a byte then the quotient will be stored on the AL register
and the residue on AH, if it was a word then the quotient is stored on AX and
the residue on DX.
IDIV INSTRUCTION
Purpose: Division with sign.
Syntax:
IDIV source
It basically consists on the same as the DIV instruction, and the only
difference is that this one performs the operation with sign.For its results it
used the same registers as the DIV instruction.
MUL INSTRUCTION
Purpose: Multiplication with sign.
Syntax:
MUL source
The assembler assumes that the multiplicand will be of the same size as the
multiplier, therefore it multiplies the value stored on the register given as
operator by the one found to be contained in AH if the multiplier is 8 bits or
by AX if the multiplier is 16 bits. When a multiplication is done with 8 bit
values, the result is stored on the AX register and when the multiplication is
with 16 bit values the result is stored on the even DX:AX register.
IMUL INSTRUCTION
Purpose: Multiplication of two whole numbers with sign.
Syntax:
IMUL source
This command does the same as the one before, only that this one does take
into account the signs of the numbers being multiplied.
The results are kept in the same registers that the MOV instruction uses.
SBB INSTRUCTION
Purpose: Subtraction with cartage.
Syntax:
SBB destiny, source
This instruction subtracts the operators and subtracts one to the result if
CF is activated. The source operator is always subtracted from the destiny.
This kind of subtraction is used when one is working with 32 bits quantities.
SUB INSTRUCTION
Purpose: Subtraction.
Syntax:
SUB destiny, source
It subtracts the source operator from the destiny.
|
