Assembly Language Programming

Assembly language is regarded as a low-level programming language because the syntax used in assembly language is very close to the hardware itself. For example, if you want to do a move/copy/assign operation, then you use an instruction called MOV that comes from the operation move.

1. 
   The program can run faster because the program can fully utilize the CPU
   
2. 
   The syntax is similar for different kinds of microprocessor so after learning the assembly language for one processor you can adapt to other processors very easily
   
3. 
   Help users to understand the architecture of the microprocessor as well as how a CPU performs its functions
   

Before you can write your program, you must know

1. 
   the operations or instructions that are supported by the microprocessor (the instruction set!). For example if there is no multiply operation in the instruction then you can only use addition to carry out a multiply.
   
2. 
   the functions of different registers, you need to utilize the registers during programming
   
3. 
   how external memory is organized and how it is addressed to obtain instructions and data
   

• 
  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 a problem solving process so we must think logically in order to derive a solution
  
• 
  Practice – write more programs
  

After you have written your program, the program will then be assembled (similar to compiled) and linked into an executable program.

The executable program could be .com, .exe, .bin, .hex files

Assembly program

xxx.asm

Example of a very simple instruction

Consider a very simple instruction mov AL, 00H, it is to move a value 00 (HEX) to the AL register of 8086.

Machine code for mov AL, 00H is B4 00 (2 bytes)

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

When the program is being executed, then the value B400 is read from memory, decoded and carried out the task.
When you write assembly language program, only put one instruction in each statement. You cannot do things like:

A=(B+C)*100
To achieve the above, you may need to do a sequence of operations:

Move B to A (A=B)

Add C to A (A=A+C)

Multiply A with 100 (A=A*100)

A statement must specify which operation (opcode) to be performed as well as the operands

AX is called the destination operand

BX is called the source operand

The result is AX = AX + BX

General format for an assembly language statement

Label Instruction Comment

Start: Mov AX, BX ; copy BX into AX

The word Start is the name of a label. A label’s name is defined by a user provided that it is not a reserved word and do not put space between the name. After the name, you must include the : to indicate that it is a label.

So Even, or odd-addressed bytes of data can be independently accessed.

In a program, if you want to use an 8-bit data, it is represented by directive db (b-byte) and 16-bit by dw (w-word).

To store a 16-bit data, the MSB (Most Significant Byte) is stored at the higher byte address and the LSB at the lower byte address.

For example a 16 bit value ABCD (Hex) will occupy two address locations, for example 12344H and 12345H, then the low byte CD will be stored in 12344H and the high byte AB will be stored in 12345H.

Only 4 64K-byte segments are active at the same time and these are: code, stack, data, and extra

To access the active segments, it is via the segment register: CS (code), SS (stack), DS (data), ES (extra). When you write your program, you sometimes need to properly define the different segments.


To get an instruction: we need to generate an address for the instruction (code).

The address for an instruction is the sum of CS and IP.

The segment register points to the lowest addressed location in the current code segment

CS + IP will give a 20-bit address

IP will be incremented so it points to the next instruction (sometimes we use term Program Counter (PC) instead of IP )

This is the concept of offset and base, do you still remember which is the offset and which is the base?

The AX register is called the accumulator, usually used for storing result after an operation.

Each of the 4 data registers can be used as the source or destination of an operation during an arithmetic, logic, shift, or rotate operation. In some operations, the use of the accumulator (AX) is assumed, eg in multiplication operation; details will be given in the following.
Special use of the data registers
In based addressing mode, base register BX is used as a pointer to an operand in the current data segment. Details given in the section on addressing modes.

The CX register 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. In a looping operation, content of CL represents the number of iterations to be executed.

DX, data register, is used in all multiplication and division operations, it also contains an input/output port address for some types of input/output operations.
Pointer and index registers
In addition to the data registers, there are the pointer and index registers, all 16-bit. Some pointer and index registers can be used as a general purpose register, ie can be used as an operand in arithmetic or logic operations. However, most pointer and index registers have special purposes.
The Stack (or the Stack segment) – is used as a temporary storage.

Data can be stored by the PUSH instruction and extracted by the POP instruction

To access the Stack, you must use the SP (Stack Pointer) and BP (Base Pointer), details will be given in the section on stack.

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

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.

Integer could be signed or unsigned and in byte-wide or word-wide format.

For a signed integer, the MSB can be used to determine the sign (0 for positive, 1 for negative).

For example the value 1001 0100 is negative if it is a signed value

The range of Signed integer (8-bit) is from 127 to –128,

For signed word (16-bit) it is from 32767 to –32768

Latest microprocessors can also support 64-bit or even 128-bit data
Example of a simple Assembly Program

The above shows a very simple 8086 assembly program. You can see the basic syntax used in the program and how the code segment is defined using the .code keyword.

The flow of the program is top-down, ie from start to end and only one statement is executed at each time.
In general, an assembly program must include the code segment!!

Code segment stores the program codes.

Other segments, such as stack segment, data segment, are not compulsory.

There are key words used to indicate the beginning of a segment as

well as the end of a segment.

Example

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

Similarly key words are used to define the beginning of a program, as well as the end.

assume ss:stacksg, ds: datasg, cs:codesg

In the above, the SS register is associated with the stacksg segment (which is the stack).
In some assembler, you need to move the base address of a segment directly into the segment register!!! Examples will be available in the following.
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
Fortunately, if you are doing something simple you do not need to include all the segment declarations in the program. For example:
start:

mov DL, 0H ; move 0H to DL

mov CL, op1 ; move op1 to CL

mov AL, data ; move data to AL

step:

cmp AL, op1 ; compare AL and op1

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 program
data db 45 ; just like a string

op1 db 6

(http://user.mc.net/~warp/software_wasm.html)

During the lectures, this software is being used to demonstrate the program examples.

You can define constants, work areas (a chunk of memory ) in your program.

Data can be defined in different length (8-bit, 16-bit)

8-bit then use DB 16-bit then use DW

The name of an item is otherwise optional

Dn – this is called the directives. It defines length of the data

Expression – define the values (content) for the data

FLDC + 1 stores the second value

DUP can be used to define multiple storages

DB 10 DUP (?) ; defines 10 bytes not initialize

DB 5 DUP (12) ; 5 data all initialized to 12

DB ‘this is a test’

a 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 12

mov CX, factor
Addressing modes
Function of the addressing modes defines how to access operands of an instruction.

There are 9 modes: register addressing, immediate addressing, direct addressing, register indirect addressing, based addressing, indexed addressing, based indexed addressing, string addressing, and port addressing

To fetch the operand, require the BIU to do the read/write bus cycle to the memory subsystem if necessary, different addressing modes provide different ways of computing the address of an operand.
Example in C++ programming, you can do:

Int *x, y;

X = &y ; this is indirect addressing

OR

Int x[10], y;

Eg MOV AX, BX

In the above operation, both operands are in the internal registers and this is called register addressing mode.

Source operand (or the immediate value) is part of the instruction

Usually immediate operands represent constant data, the operands can be either a byte or word

e.g MOV AL, 15

15 is a byte wide immediate source operand

Or it could be MOV AL, #15

The immediate operand is stored in program storage memory (i.e the code segment)

This value is also fetched into the instruction queue in the BIU and no external memory bus cycle is initiated!

This is also a simple addressing mode and it is for moving a byte or word between a memory location and a register. The memory location most likely represents a variable.

The locations following the instruction opcode hold an Effective memory Address (EA) instead of the data.

The EA is an offset address representing 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!

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

The pointer register can be either the base register BX or base pointer register BP.

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

The default segment is either DS or ES.

Refer to the following memory table

If SI = 01235H then after the move then AL = 18 according to the following memory table.

Value stored in the SI register is used as the offset address. Using the offset address, you can then obtain the Physical address of the data.

The segment register is DS in this example

In register indirect addressing mode, the EA (effective address) is a variable and depends on the index, or base register value

Eg mov [BX], CL

If CL = 88 and BX = 01233 then after the move content of address 01233H becomes 88

Which segment register will be used for the above operation?

This moves a byte or a word between a register and the memory location addressed by a base register (BP or BX) plus an index register (DI or SI). You need a base value and an index in order to extract the proper data.

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 register instead of DS

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

EA = value of SI + address of 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
For the transfer of a byte or a word between a register and the memory location addressed by a base and an index register plus a displacement, there are 3 components.

This addressing mode is a combination of the based addressing mode and the indexed addressing mode together

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]
Summary of different addressing modes

MOV AL, BL	Register addressing mode
MOV AL, 15H	immediate
MOV AL, abc MOV AL, [1234H]	direct
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

In register indirect addressing mode such as MOV AL, [SI] the value of SI represents an address. How to move an address of a variable to a register?

This is achieved by the instruction LEA (load effective address).

LEA is similar to the following C++ syntax

int* x ;

MOV AL, [SI] ; value of 12 is moved to AL

1. Select an instruction for each of the following tasks:

• 
  Copy content of BL to CL
  
• 
  Copy content of DS to AX
  

2. Suppose that DS=1100H, BX=0200H, LIST=0250H, and SI=0500H, determine the physical address being accessed by each of the following instructions:

mov CL, LIST[BX+SI]

mov CH, [BX+SI]
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.

The 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 so you must set the value of SI and DI before you use MOVS.

For ports in the I/O address space, only the direct addressing mode and an indirect addressing mode using DX are available

Input data from the input port at address 15₁₆ of the I/O address space to register AL

Eg IN AL, DX

Load AL with data coming from a port, which number is stored in DX

MOV [DI], AX (destination operand)

MOV DI, [SI] (source operand)

MOV XYZ[DI], AH (destination operand)

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

BX=0300, XYZ=0400

2. Express the decimal numbers that follows as unpacked and packed BCD bytes (BCD – binary coded decimal)

1. 
   29 b. 88
   

Determine which is being moved in each “MOV” statement for the following assembly program.

dat segment para 'data'

ival db 10H

array db 8, 2, 3, 4

dat ends
; COM file is loaded at CS:0100h
; define the code segment - instructions

CSEG segment 'code'

beng proc FAR

mov AX, dat ; assign data segment address to AX

mov DS, AX ; now DS is pointing to the data segment or DS stores the base ; address of the data segment
mov AX, BX ; register addressing mode

mov BL, ival ; direct addressing

mov AL, 7fH ; immediate addressing mode

mov BL, 04fH

add AL, BL ; AL = AL+BL

mov [10], AL ; direct addressing mode

mov CL, [11]

mov cl, array+2

LEA BX, array ; load effective address of array to BX

mov al, 2

mov dl, [bx] ; register indirect addressing

mov SI, 2

mov dh, [bx+SI] ; base+index addressing

mov ah, array[3] ; base relative addressing

mov al, [bx+si+1] ; base relative + index

mov cl, array+2

beng endp

CSEG ends