Assembly language programming Learning assembly language programming will help understanding the...

Assembly language programming

• Learning assembly language programming will help understanding the operations of the microprocessor

• To learn:– Need to know the functions of various registers – Need to know how external memory is organized and

how it is addressed to obtain instructions and data (different addressing modes)

– Need to know what operations (or the instruction set) are supported by the CPU. For example, powerful CPUs support floating-point operations but simple CPUs only support integer operations

How to learn programming• C –Concept • L – Logic thinking• P – Practice • Concept – we must learn the basic syntax, such as

how a program statement is written• Logic thinking – programming is problem solving

so we must think logically in order to derive a solution

• Practice – write programs

Assembly Program• The native language is machine language (using 0,1

to represent the operation)• A single machine instruction can take up one or

more bytes of code• Assembly language is used to write the program

using alphanumeric symbols (or mnemonic), eg ADD, MOV, PUSH etc.

• The program will then be assembled (similar to compiled) and linked into an executable program.

• The executable program could be .com, .exe, or .bin files

Flow of program development

Program.asm

Object file.obj

Executable file .exe

Assemble link

Example• Machine code for mov AL, 00H

• B4 00 (2 bytes)

• After assemble, the value B400 will be stored in the memory

• When the program is executed, then the value B400 is read from memory, decoded and carry out the task

Assembly Program • Each instruction is represented by one assembly language

statement • The statement must specify which operation (opcode) is to

be performed and the operands• Eg ADD AX, BX • ADD is the operation• AX is called the destination operand • BX is called the source operand• The result is AX = AX + BX• When writing assembly language program, you need to

think in the instruction level

Example• In c++, you can do A = (B+C)*100

• In assembly language, only one instruction per statementA = B ; only one instruction - MOVE

A = A+C ; only one instruction - ADD

A = A*100 ; only one instruction - Multiply

Format of Assembly language• General format for an assembly language

statement• Label Instruction Comment• Start: Mov AX, BX ; copy BX into AX

Start is a user defined name and you only put in a label in your statement when necessary!!!!

The symbol : is used to indicate that it is a label

8086 Software Model

Software model• In 8086, memory is divided into segments• Only 4 64K-byte segments are active and these are: code,

stack, data, and extra

• When you write your assembly language program for an 8086, theoretically you should define the different segments!!!

• To access the active segments, it is via the segment register: CS (code), SS (stack), DS (data), ES (extra)

• So when writing assembly language program, you must make use of the proper segment register or index register when you want to access the memory

Registers• In assembly programming, you cannot

operate on two memory locations in the same instruction

• So you usually need to store (move) value of one location into a register and then perform your operation

• After the operation, you then put the result back to the memory location

• Therefore, one form of operation that you will use very frequent is the store (move) operation!!!

• And using registers!!!!!

Example• In C++ A = B+C ; A, B, C are variables

• In assembly language A,B, C representing memory locations so you cannot do A = B+C – MOV AL, B ; move value of B into AL

register– ADD, AL, C ; do the add AL = AL +C– MOV A, AL ; put the result to A

Data registers• AX, BX, CX,and DX – these are the general purpose

registers but each of the registers also has special functionExample

– AX is called the accumulator – to store result in arithmetic operations

• Registers are 16-bit but can be used as 2 8-bit storage• Each of the 4 data registers can be used as the source or

destination of an operand during an arithmetic, logic, shift, or rotate operation.

• In some operations, the use of the accumulator is assumed, eg in I/O mapped input and output operations

Data register

• In based addressing mode, base register BX is used as a pointer to an operand in the current data segment.

• CX is used as a counter in some instructions, eg. CL contains the count of the number of bits by which the contents of the operand must be rotated or shifted by multiple-bit rotate

• DX, data register, is used in all multiplication and division, it also contains an input/output port address for some types of input/output operations

Pointer and index registers• Stack – is used as a temporary storage• Data can be stored by the PUSH instruction and

extracted by the POP instruction• Stack is accessed via the SP (Stack Pointer) and BP

(Base Pointer)• The BP contains an offset address in the current

stack segment. This offset address is employed when using the based addressing mode and is commonly used by instructions in a subroutine that reference parameters that were passed by using the stack

Pointer and Index Register• Source index register (SI) and Destination index

register (DI) are used to hold offset addresses for use in indexed addressing of operands in memory

• When indexed type of addressing is used, then SI refers to the current data segment and DI refers to the current extra segment

• The index registers can also be used as source or destination registers in arithmetic and logical operations. But must be used in 16-bit mode

Data types• Data can be in three forms: 8-bit, 16-bit, or 32-bit (double

word)• Integer could be signed or unsigned and in byte-wide or

word-wide• For signed integer (2’s complement format), the MSB is

used as the sign-bit (0 for positive, 1 for negative)• Signed 8-bit integer 127 to –128, • For signed word 32767 to –32768• Latest microprocessors can also support 64-bit or even

128-bit data• In 8086, only integer operations are supported!!!

A sample program.code ; indicate start of code segment.startup ; indicate start of programmov AX, 0 mov BX, 0000Hmov CX, 0mov SI, AXmov DI, AXmov BP, AX

END ; end of fileThe flow of the program is usually top-down and instructions are executed one by one!!!

Assembly programmingIn general, an assembly program must include the code segment!!Other segments, such as stack segment, data segment are notcompulsory

There are key words to indicate the beginning of a segment aswell as the end of a segment. Just like using main(){} in C++ Programming

ExampleDSEG segment ‘data’ ; define the start of a data segment

DSEG ENDS ; defines the end of a data segmentSegment is the keyword DSEG is the name of the segmentSimilarly key words are used to define the beginning of a program,as well as the end.

Assembly language programmingExample

CSEG segment ‘code’START PROC FAR ; define the start of a program (procedure)

RET ; return START ENDP ; define the end of a procedureCSEG ends

End start ; end of everything

Different assembler may have different syntax for the definitionof the key words !!!!!Start is just a name it could be my_prog, ABC etc

More sampleStacksg segment para ‘stack’ …. ; define the stack segmentStacksg endsDatasg segment para …… ; declare data inside the data segmentDatasg endsCodesg segment para ‘code’Main proc far ;

assume ss:stacksg, ds: datasg, cs:codesgmov ax, datasgmov ds, ax….mov ax, 4c00Hint 21H

Main endpCodesg ends

end mainEnd of everything

DefinitionsTo declare a segment, the syntax is:segment_name SEGMENT alignment classExample Stacksg segment PARA (this statement is used in previous slide)PARA – define the alignment of the segment base address, the segment with a starting addressing that is evenly Divisible by 16 (ie the last digit is 0). But the default value is also base address divisible by 16 so the key word PARA can be ignored!

Definition• ‘data’, ‘code’ – class entry. Is used to group

related segments when linking. The linker automatically groups segments of the same class in memory

• PROC – define procedures (similar to a function) inside the code segment. Each procedure must be identified by an unique name. At the end of the procedure, you must include the ENDP

DefinitionsFAR – is related to program execution. When you request execution

of a program, the program loader uses this procedure as the entry

point for the first instruction to execute.

Assume – to associate, or to assign, the name of a segment with a segment register (ie let CS point to the code segment, DS points to data segment etc)

In some assembler, you need to move the base address of a segment directly into the segment register!!!

END – ends the entire program and appears as the last statement. Usually the name of the first or only PROC designated as FAR is put after END

Syntax of a simple assembly language program

• If you are doing something simple then you do not need to define the segment

• Everything will be stored in the code segment

start: mov DL, 0H ; move 0H to DL mov CL, op1 ; move op1 to CL mov AL, data ; move data to ALstep: cmp AL, op1 ; compare AL and op1 jc label1 ; if carry =1 jump to label1 sub AL, op1 ; AL = AL –op1 inc DL ; DL = DL+1 jmp step ; jump to step label1: mov AH, DL ; move DL to AH HLT ; Halt end of programdata db 45 ; define a variable called dataop1 db 6 ; define a variable called op1

Assembler for 8086WASM – a freeware can be download from internet (http://user.mc.net/~warp/software_wasm.html)

Emu8086 (http:// www.emu8086.com) – there is a trial version but it does not support all the features such as interruptThe emu8086 consists of a tutorial and the reference for a complete instruction set

Keil – www.keil.com

http://www.emu8086.com/

Defining data in a programData is usually stored in the data segment You can define constants, work areas (a chunk of memory )Data can be defined in different length (8-bit, 16-bit)8-bit then use DB 16-bit then use DW

The definition for data:

[name] Dn expression ; Dn is either DB or DW

Name – a program that references a data item by means of a name. The name of an item is otherwise optional Dn – this is called the directives. It defines length of the dataExpression – define the values (content) for the data

Examples for data FLDA DB ? ; define an uninitialized item called FLDA 8-bit

FLDB DB 25 ; initialize a data to 25

Define multiple data under the same name (like an array)

FLDC DB 21, 22, 23, 34 ; the data are stored in adjacent bytes

FLDC stores the first value FLDC + 1 stores the second value

You can do mov AL, FLDC+3

Example for data definitionDUP – duplicate DUP can be used to define multiple storagesDB 10 DUP (?) ; defines 10 bytes not initializeDB 5 DUP (12) ; 5 data all initialized to 12

String : DB ‘this is a test’

EQU – this directive does not define a data item; instead, it definesa value that the assembler can use to substitute in other instructions(similar to defining a constant in C programming or using the #define )factor EQU 12mov CX, factor

Assembly Program• Assembly language should be more effective and

it will take up less memory space and run faster• In real-time application, the use of assembly

program is required because program that is written in a high-level language probably could not respond quickly enough

• You can also put assembly codes into your C++ program in order to reduce the execution time!!!!

Assembly language programming

• The syntax for different microprocessor may be different but the concept is the same so once you learn the assembly programming for one microprocessor, you can easily program other kinds of system

• For example, programming the 8051 series is very similar to the 8086

Addressing Modes• Function of the addressing modes is to access the

operands• Available modes (9 modes): register addressing,

immediate addressing, direct addressing, register indirect addressing, based addressing, indexed addressing, based indexed addressing, string addressing, and port addressing

• Addressing modes provide different ways of computing the address of an operand so that you can utilize your data with different techniques

Why addressing mode is important?• In c++, you can define an array, or a variable

– int x[10], y, *z; – Then to access different elements, you can do – Z = x ; – *(x+2); – x[0] = y

How this can be done using assembly language programming? This is via different addressing modes!!!!

Register addressing mode

• The operand to be accessed is specified as residing in an internal register of the 8086

• Eg MOV AX, BX

• Move (MOV) contents of BX (the source operand), to AX (the destination operand)

• Both operands are in the internal registers

Pay attention to the value of IP and content of AX, BX

Immediate addressing modeSource operand is part of the instruction Usually immediate operands represent constant dataThe operands can be either a byte or word e.g MOV AL, 1515 is a byte wide immediate source operandOr it could be MOV AL, #15The immediate operand is stored in program storage memory (i.e the code segment)This value is also fetched into the instruction queue in the BIUNo external memory bus cycle is initiated!

Direct addressing mode• Move a byte or word between a memory location

and a register• the locations following the instruction opcode

hold an effective memory address (EA) instead of data

• The address is a 16-bit offset of the storage location of the operand from the current value in the data segment register

• Physcial address = DS + offset• The instruction set does not support a memory-to-

memory transfer!

Direct addressing• Data is assumed to be stored in the data segment

so DS is used in calculating the physical address!!!

• External memory bus cycle is needed to do the read

• Example of direct addressing: mov AL, var1• Where Var1 can be regarded as a variable

Register indirect addressing mode

• Transfer a byte or word between a register and a memory location addressed by an index or base register– Example MOV AL, [SI]– SI – index register– The symbol [] always refer to an indirect addressing

• The effective address (EA) is stored either in a pointer register or an index register

• The pointer register can be either base register BX or base pointer register BP

• The index register can be source index register SI, or destination index register DI

• The default segment is either DS or ES

Register indirect addressing• Eg MOV AX, [SI]• Value stored in the SI register is used as the offset

address• The segment register is DS in this example• Meaning of the above is to move the data stored in

the memory location : DS + SI to the AX register• In register indirect addressing mode, the EA

(effective address) is a variable and depends on the index, or base register value

Address (in HEX)

Content

01236 19

01235 18

01234 20

01233

According to the memory mapThe result of the operation Mov [BX], CL will result in what???If CL = 88 and BX = 1233H and DS =0H

Physical address = DS + BX = 01233H

Different Addressing modesMOV AL, BL Register addressing mode

MOV AL, 15H immediate

MOV AL, abc

MOV AL, [1234H]

Direct abc is a variable1234H is the offset address

MOV AL, [SI] Register indirect

MOV AL, [BX+SI] Base plus index

MOV AL, [BX+4]

MOV AL, ARRAY[3]

Register relative

MOV AL, [BX+DI+4]

MOV AL, ARRAY[BX+DI]

Base relative plus index

How to move the address of a variable to a register ?

• When using indirect addressing, such as– MOV AL, [SI]– SI is an address so how can we initialize SI?

• This is by the instruction called LEA (Load Effective Address)

• LEA is similar to x = &y in C++• Syntax of LEA:

– LEA SI, ARRAY

Base-plus-index addressing mode• Move a byte or word between a register and the

memory location addressed by a base register (BP or BX) plus an index register (DI or SI)

• Physical address of the operand is obtained by adding a direct or indirect displacement to the contents of either base register BX or base pointer register BP and the current value in DS and SS, respectively.

• Eg MOV [BX+SI], AL• Move value in AL to a location (DS+BX+SI)• If BP is used then use SS instead of DS

Application of Base + index• The base register (BX) often holds the

beginning location of a memory array, while the index register (SI) holds the relative position of an element in the array

• Change the value of SI then you can access different elements in the array

Register relative addressing mode

• Move a byte or word between a register and memory location addressed by an index or base register plus a displacement

• Eg MOV AL, ARRAY[SI]• EA = value of SI + ARRAY• Physical address = EA + DS• Eg mov AX, [BX+4]• Eg mov AX, array[DI+3]• This is similar to the base-plus-index

Base relative plus index addressing mode

• Transfers a byte or word between a register and the memory location addressed by a base and an index register plus a displacement

• Combining the based addressing mode and the indexed addressing mode together

• Eg MOV AH, [BX+DI+4]• EA = value of BX + 4 + value of DI• Physical address = DS + EA • This can be used to access data stored as a 2-D

matrix• Eg mov AX, array[BX+DI]

Example• Select an instruction for each of the following tasks:

– Copy BL into CL• Mov CL, BL

– Copy DS into AX• Mov AX, DS

Suppose that DS=1100H, BX=0200H, LIST=0250H, and SI=0500H, determine the address accessed by each of the following instructions:mov LIST[SI], DX (offset address: LIST + SI=0750H, PA = offset +DS = 11750H) mov CL, LIST[BX+SI] ( offset address: LIST+BX+SI = 0950H, PA = 11950H)mov CH, [BX+SI] (offset address: BX+SI = 0700H, PA = 11700H)

String addressing mode

• The string instructions of the 8086 instruction set automatically use the source (SI) and destination index registers (DI) to specify the effective addresses of the source and destination operands, respectively.

• Instruction is MOVS• There is no operand after movs• Don’t need to specify the register but SI and

DI are being used during the program execution

Port addressing mode• Port addressing is used in conjunction with IN and OUT

instruction to access input and output ports. • Any of the memory addressing modes can be used for the

port address for memory-mapped ports.• For ports in the I/O address space, only the direct addressing

mode and an indirect addressing mode using DX are available• Eg IN AL, 15H ; second operand is the port number• Input data from the input port at address 1516 of the I/O

address space to register AL• Eg IN AL, DX• Load AL with port number stored in DX

Exercises1. Compute the physical address for the specified operand in each of the

following instructions:

MOV [DI], AX (destination operand)

[DI] refers to the address 0200 so PA = 0B200H

MOV DI, [SI] (source operand)

[SI] refers to 0100 so PA = 0B100H)

MOV XYZ[DI], AH (destination operand)

XYZ[DI] refers to 0400+0200, PA = 0B600H

Given CS=0A00, DS=0B00, SI=0100, DI=0200,

BX=0300, XYZ=0400

Exercises2. Express the decimal numbers that follows as unpacked and

packed BCD bytes (BCD – binary coded decimal)

a. 29 b. 88

Ans. unpacked BCD takes 1 byte per-digit so 29 becomes

00000010 00001001 as packed 00101001

3. How would the BCD numbers be stored in memory starting at address 0B000

Ans. if it is packed BCD then 29 will occupy one byte at 0B000, if as unpacked BCD then it occupies 2 bytes 00000010 at 0B001 and 00001001 at 0B000)

Instruction set• A total of 117 basic instructions• 5 groups: data transfer, arithmetic, logic, shift, and

rotate• Data transfer instructions – to move data either

between its internal registers or between an internal register and a storage location in memory

• Cannot move data from one memory location to another memory location

• When the segment register is used as an operand then the move instruction must apply to a 16-bit data

• Mov SS, data ; then data must be 16-bit

Move instruction Mnemonic Meaning Format Operation Flags affected

Mov Move mov D,S (S) to (D) none

Destination (D) Source (S)

Memory AX

AX Memory

Register Register

Register Memory

Memory Register

Register Immediate

Memory Immediate

Seg-reg Reg16

Seg-reg Mem16

Reg16 Seg-reg

Mem16 Seg-reg

Special data transfer instructions• XCHG – exchange data between the source and

destination• Eg XCHG AX, DX• Then value in DX is stored in AX and value in AX

stored in DX

Special data transfer instruction• LEA – load effective address• LEA is are very important operation

because it allows you to obtain an address of a variable or an array then you can apply the relative addressing modes!!!!

• Eg LEA SI,INPUT• To load a specified register with a 16-bit

offset address• Similar to x = &y in a C++ program

Example of LEA

Dat db 11H, 22H, 33H, 44H

LEA BX, datMov AL, [BX+2] ; this is register relative addressing mode

What is being stored in AL ?????

• LDS – load register and DS• Eg LDS SI, [200]• LDS will load a specified register (SI) and

the DS • 4 bytes of data will be fetched the first two

stored in SI and the following two stored in DS

• LES – load register and ES• LES will load a specified register and the

ES

Arithmetic instructions

• Some examples of available arithmetic operations: add, substract, multiply, etc.

• Can apply to unsigned, signed, binary bytes, words, unpacked, packed decimal bytes, or ASCII numbers

• Packed decimal – two BCD digits are packed into a byte register or memory location

• Unpacked decimal numbers are stored one BCD digit per byte

• After an arithmetic operation, the flags are updated accordingly

Arithmetic instructionsADD Add byte or word

ADC Add byte or word with carry

Inc Increment byte or word by 1

AAA ASCII adjust for addition

DAA Decimal adjust for addition

Sub Subtract byte or word

Sbb Subtract byte or word with borrow

DEC Decrement byte or word by 1

NEG Negate byte or word

AAS ASCII adjust for subtraction

DAS Decimal adjust for subtraction

MUL Multiply byte or word unsigned

IMUL Integer multiply byte or word

AAM ASCII adjust for multiply

Div Divide byte or word unsigned

Idiv Integer divide byte or word

AAD ASCII adjust for division

CBW Convert byte to word

CWD Convert word to doubleword

Addition related operationsMnemonic Meaning Format Operation Flags affected

Add Addition Add D, S D = S+D

CF = carry

OF, SF, ZF, AF, PF, CF

ADC Add with carry ADC D, S

D = S+D+CF

CF = carry


INC Increment by 1 INC D D = D+1 OF, SF, ZF, AF, PF

AAA ASCII adjust for addition

AAA AF, CF, OF, SF, ZF, PF undefined

DAA Decimal adjust for addition

DAA SF, ZF, AF, PF, CF, OF undefined

Destination Source

Register Register

Register Memory

Memory Register

Register Immediate

Memory Immediate

AX Immediate

Subtraction

Mnemonic Meaning Format Operation Flags affected

Sub Subtract Sub D,S D = D-S

CF = borrow


Sbb Subtract with borrow

SBB D,S D = D-S-CF OF, SF, ZF, AF, PF, CF

Dec Decrement by 1 DEC D D=D-1 OF, SF, ZF, AF, PF

Neg Negate Neg D D=0-D

CF =1


DAS Decimal adjust for subtraction

DAS OF, SF, ZF, AF, PF, CF undefined

AAS ASCII adjust for subtraction

AAS OF, SF, ZF, AF, PF, CF undefined

Subtraction operands

Destination Source

Register Register

Register Memory

Memory Register

AX Immediate

Register Immediate

Memory immediate

Example

If BX = 3A NEG BXGive FFC6

NEG – make the operand negative (2’s complement)Executing the NEG instruction causes the following 2’s complement subtraction00 - (BX) = 0000 + 2’s complement of 3A

= 0000 + FFC6 = FFC6

Multiplication• When multiplying 8-bit data, result is 16-bit and

stored in AX• When multiplying 16-bit data, result is 32-bit and

result stored in AX and DX • The AX holds the LSB and DX MSB• Only the source operand is specified and the other

operand is in AL, or AX. This is also the same in division

• In division, AH is the remainder and AL is the quotient

• For 16-bit, AX contains the quotient and DX contains the remainder

Multiplication and division functions


MUL Multiply

(Unsigned)

MUL S AX = AL*S8

DX,AX = AX*S16

OF, CF, SF, ZF, AF, PF undefined

DIV Division

(unsigned)

DIV S AL = Q (AX/S8)

AH = R(AX/S8)


IMUL Integer multiply

(signed)

IMUL S AX = AL*S8

DX,AX=AX*S16


IDIV Integer divide

(signed)

IDIV S AX = Q(AX/S8)

AH=R(AX/S8)

AX = Q(DX,AX)/S16

DX=R(DX,AX)/S16

If Q is positive and exceeds 7FFF or if Q is negative and becomes less than 8001 then type 0 interrupt occurs


Multiplication related functions


AAM Adjust AL for multiplication

Ascii adjust after Multiplication for BCD values

AAM AH=Q(AL/10)

AL=R(AL/10)

SF, ZF, PF, OF, AF, CF undefined

AAD Adjust AX for division

Prepare 2 BCD values for division

AAD AL=(AH*10+AL)

AH =00

SF, ZF, PF, OF, AF, CF undefined

CBW Convert byte to word

CBW All bits of AH = (MSB of AL)

None

CWD Convert word to double word

CWD All bits of DX = MSB of AX

none

Example

If AL is –1 and CL is –2, what will be the result produced In AX forMUL CLIMUL CL

MUL CL is unsigned multiply = FD02IMUL CL is signed multiply = 2

Special functions• CBW – convert byte (8-bit) to word (16-bit)• CBW – fill AH with 0 if AL is positive; fill AH

with 1s if AL is negative then AH becomes FF• CWD – convert word (16-bit) to double word (32-

bit) and the DX register is used to store the high order word

• CWD – fill DX with 0 if AL is positive; fill DX with 1s if AX is negative then DX becomes FF

• Use CBW when doing 8-bit operation• Use CWD when doing 16-bit operation

ExampleWhat is the result of executing the following sequence Of instructions?MOV AL, A1CBWCWD

Ans.AX = FFA1 after CBWDX = FFFF after CWD

A simple application

• Try to write a simple assembly program to convert from Centigrade (Celsius) to Fahrenheit

• The equation for the conversion is

• f = c * 9 / 5 + 32

• What operations are required?

• Do you need to define variables?

Logic Instructions

• Logic operations include: AND, OR, exclusive-OR (XOR) and NOT

• Eg AND AX, BX

• Result is stored in AX

• Operation is applied to bits of the operands

Exercise• Describe the result of executing the

following:• MOV AL, 01010101B

• AND AL, 00011111B (AL = 00010101B)

• OR AL, 11000000B (AL = 11010101B)

• XOR AL, 00001111B (AL = 11011010B)

• NOT AL (AL = 00100101B)

Ans. AL = 00100101

NOTE: NOT not equal to NEG

Application of logical operations• If you only want to examine a particular bit

in a 8-bit pattern you can do– AND AL, #00010000

The above tries to examine bit 4 of AL

After AND check the ZERO flag

Z=1 then bit4 =0 else bit4=1

• If you want to clear a register to 0 – XOR BL, BL

Exercise

• Write a program to count the number of even numbers included in an array by using:– Logical operation(s)

Shift Instructions• There are 4 shift operations • Can perform: logical shift and arithmetic shift• Can shift left as well as right• Logical shift – the vacated bit will be filled with ‘0’• Arithmetic shift – the vacated bit will be filled with the

original most significant bit (this only applies in right shift, in left shift vacated bit is filled with ‘0’ as well.)

• Arithmetic shift will maintain the ‘sign’ of the original data

• If shift more than 1 bit then the number of bits to be shifted is stored in CL

Shift leftcarry

If content is 10010011 then after shift Carry = 1 result is 00100110

If content is 10010011 then after shift Carry = 1 result is 01001001If arithmetic shift then result is 11001001

Shift right carry

Shift operationsMnemonic Meaning Format Operation Flags affected

SAL/SHL Shift arithmetic left/shift logical left

SAL/SHL D, Count

Shift the (D) left by the number of bit positions equal to count and fill the vacated bits positions on the right with zeros

CF, PF, SF, ZF, OF, AF undefined

OF undefined if count not equal to 1

SHR Shift logical right SHR D, Count Shift the (D) right by the number of bit positions equal to count and fill the vacated bits positions on the left with zeros


OF undefined if count not equal to 1

SAR Shift arithmetic right SAR D, Count Shift the (D) right by the number of bit positions equal to count and fill the vacated bits positions on the left with the original most significant bit


OF undefined

Rotate Instructions

• Rotate is similar to shift • The vacate bit is filled with the bit rotated out

from the other side• Rotate left through carry (RCL) – bit rotated out is

stored in the carry flag, the vacated bit is filled by the carry flag

Rotate

1 1 1 1 0 0 0 0

0 1 1 1 1 0 0 0

0 1 1 1 1 0 0 0

Rotate right

After

1

1 0 1 1 1 1 0 0 0

Rotate right thro’ carry

After

Example of rotate

• Eg RCR BX, CL ; rotate right thro’ carry

• If CL = 0416 and BX = 123416 what is the result of the above operation? – 1000 0001 0010 0011 if C is 0 at the beginning

Rotate Operations


ROL Rotate left ROL D, Count Rotate the D left by the number of bit positions equal to Count. Each bit shifted out from the leftmost bit goes back into the rightmost bit position

CF

OF undefined if count 1

ROR Rotate

right

ROR D, Count Rotate the D right by the number of bit positions equal to Count. Each bit shifted out from the rightmost bit goes back into the leftmost bit position

CF


Rotate operationMnemonic Meaning Format Operation Flags affected

RCL Rotate left thro’ carry

RCL D, Count Same as ROL except carry is attached to D for rotation

CF


RCR Rotate right thro’ carry

RCR D, Count Same as ROL except carry is attached to D for rotation

CF


Applications of shift/rotate• To examine bit 6 of the AL register

– RCL AL, 2• To implement a multiply

– Shift a pattern to left = x2– 00000100 = 4 after shifting to left 00001000 = 8 – Shift to right = /2– 00000100 after shifting to right 00000010 = 2

• 3x9– Binary pattern of 9 = 1001 – 3x9 = 3 x 23 + 3x20

– 3x23 = shifting pattern of 3 to left 3 times + the original value (shift 0 time)– Binary pattern of 3 00000011– 00011000 (after 3 shift) + 00000011– Result = 00011011 = ???

Exercise

If AL = 128, BL = -4After the following:

ADD AL, 3ADC BL, ALRCL BL, 1 ; this is rotate left thro’ carry, this does not change the

; sign or overflow

Q. What will be the carry, sign and overflow flag?

Exercise

• Write a program to count the number of odd numbers included in an array by using:

– Shift/rotate operation

Exercise

AX = 0010H BX = 0020H CX = 0030H DX = 0040HSI = 0100H DI = 0200H CF = 1HDS:100 = 10H DS:101 = 00H DS:120 = FFHDS:121 = FFH DS:130 = 08H DS:131 = 00HDS:150 = 02H DS:151 = 00H DS:200 = 30HDS:201 = 00H DS:210 = 40H DS:211 = 00HDS:220 = 30H DS:221 = 00H

ADD AX, 00FF ( AX = 010F H)

ADC SI, AX (SI = 0111H)

INC BYTE PTR [0100]; Byte ptr indicate the size of memory data addressed by the memory pointer

(the value refers to is 10H so it becomes 11H)

SUB DL, BL (DL = 40 BL =20 so result = 20H)

SBB DL, [0200] (DL = 40H, [0200] refers to 30H so result is 09H )

DEC BYTE PTR [DI+BX] (data refers to by byte ptr [DI+BX] is 30H after DEC = 29H )

NEG BYTE PTR [DI] + 0010 ( NEG 40H = 1100 0000 )

MUL DX (10x40 so AX = 0400H DX = 0000H )

IMUL BYTE PTR [BX + SI] (AX = 0FF0H , DX = 0000H)

DIV BYTE PTR[SI] + 0030 (value refers to by Byte PTR[SI]+0030 is 08H (one byte) so after the division AH = 00 AL = 02)

IDIV BYTE PTR [BX][SI]+0030 ( the value refers to is 02H so after div AH =00 AL =08)

Exercise1. How would the decimal number 1234 be coded in ASCII and stored in

memory starting at address 0C000H? Assume that least significant digit is stored at the lower addressed memorylocation1 = (31H in 0C003H) 2 = (32H in 0C002H) 3 = (33H in 0C001H) 4 = (34H in 0C000H)

2. If register BX contains the value 010016, register DI contains 0010 and register DS contains 1075, what physical memory location is swapped when the following instruction is executedXCHG [BX+DI], AXPA = 10750+0100+0010 = 10860H

3. Compute the physical address for the specified operand in each of the following instructions:MOV [DI], AX (destination operand) (0B000+0200 = 0B200)MOV DI, [SI] (source operand) (0B000+0100 = 0B100)MOV DI+XYZ, AH (destination operand) (0B000+0200+0400 = 0B600)

Given CS=0A00, DS=0B00, SI=0100, DI=0200, BX=0300, XYZ=0400

Assembly language programming Learning assembly language programming will help understanding the...

Documents

Transcript of Assembly language programming Learning assembly language programming will help understanding the...