Microcontroller

Part 9: Numbers Strings and Array in Assembly Language

by Jesmin Akther | Jul 1, 2021 | Assembly Language

Numbers Strings and Array in Assembly:

In Assembly Language the preferable data types consisted on Numbers, Strings and Arrays  respectively. The article discuss each of the with the declaration and explanation with code.

Numbers in Assembly

Numerical data is generally represented in binary system. Arithmetic instructions operate on binary data. When numbers are displayed on screen or entered from keyboard, they are in ASCII form. We have converted this input data in ASCII form to binary for arithmetic calculations and converted the result back to binary. The following code shows this:

section .text

   global _start        ;must be declared for using gcc               

_start:                   ;tell linker entry point

   mov    eax,'3'

   sub     eax, '0'              

   mov    ebx, '4'

   sub     ebx, '0'

   add     eax, ebx

   add     eax, '0'

               

   mov    [sum], eax

   mov    ecx,msg

   mov    edx, len

   mov    ebx,1              ;file descriptor (stdout)

   mov    eax,4              ;system call number (sys_write)

   int       0x80                ;call kernel               

   mov    ecx,sum

   mov    edx, 1

   mov    ebx,1              ;file descriptor (stdout)

   mov    eax,4              ;system call number (sys_write)

   int       0x80                ;call kernel               

   mov    eax,1              ;system call number (sys_exit)

   int       0x80                ;call kernel               

section .data

msg db "The sum is:", 0xA,0xD

len equ $ - msg  

segment .bss

sum resb 1

OUTPUT:

The sum is:

7

Such conversions, however, have an overhead, and assembly language programming allows processing numbers in a more efficient way, in the binary form. Decimal numbers can be represented in two forms:

1. ASCII form
2. BCD or Binary Coded Decimal form

ASCII Representation

In ASCII representation, decimal numbers are stored as string of ASCII characters. For example, the decimal value 1234 is stored as:

31           32           33           34H

Where, 31H is ASCII value for 1, 32H is ASCII value for 2, and so on. There are four instructions for processing numbers in ASCII representation :

• AAA − ASCII Adjust After Addition
• AAS − ASCII Adjust After Subtraction
• AAM − ASCII Adjust After Multiplication
• AAD − ASCII Adjust Before Division

These instructions do not take any operands and assume the required operand to be in the AL register. The following example uses the AAS instruction to demonstrate the concept:

section .text

   global _start        ;must be declared for using gcc               

_start:                   ;tell linker entry point

   sub     ah, ah

   mov     al, '9'

   sub     al, '3'

   aas

   or      al, 30h

   mov     [res], ax               

   mov    edx,len         ;message length

   mov    ecx,msg         ;message to write

   mov    ebx,1             ;file descriptor (stdout)

   mov    eax,4             ;system call number (sys_write)

   int       0x80               ;call kernel              

   mov    edx,1             ;message length

   mov    ecx,res         ;message to write

   mov    ebx,1             ;file descriptor (stdout)

   mov    eax,4             ;system call number (sys_write)

   int       0x80               ;call kernel              

   mov    eax,1             ;system call number (sys_exit)

   int       0x80               ;call kernel               

section .data

msg db 'The Result is:',0xa           

len equ $ - msg                                

section .bss

res resb 1

OUTPUT

The Result is:

6

BCD Representation

There are two types of BCD representation:

1. Unpacked BCD representation
2. Packed BCD representation

In unpacked BCD representation, each byte stores the binary equivalent of a decimal digit. For example, the number 1234 is stored as:

01           02           03           04H

There are two instructions for processing these numbers:

• AAM − ASCII Adjust After Multiplication
• AAD − ASCII Adjust Before Division

The four ASCII adjust instructions, AAA, AAS, AAM, and AAD, can also be used with unpacked BCD representation. In packed BCD representation, each digit is stored using four bits. Two decimal digits are packed into a byte. For example, the number 1234 is stored as:

 12           34H

There are two instructions for processing these numbers:

• DAA − Decimal Adjust After Addition
• DAS − decimal Adjust After Subtraction

There is no support for multiplication and division in packed BCD representation.

Example

The following program adds up two 5-digit decimal numbers and displays the sum. It uses the above concepts:

section .text

   global _start        ;must be declared for using gcc

_start:                   ;tell linker entry point

   mov     esi, 4       ;pointing to the rightmost digit

   mov     ecx, 5       ;num of digits

   clc

add_loop: 

   mov    al, [num1 + esi]

   adc      al, [num2 + esi]

   aaa

   pushf

   or        al, 30h

   popf               

   mov    [sum + esi], al

   dec     esi

   loop    add_loop               

   mov    edx,len         ;message length

   mov    ecx,msg         ;message to write

   mov    ebx,1             ;file descriptor (stdout)

   mov    eax,4             ;system call number (sys_write)

   int       0x80               ;call kernel               

   mov    edx,5             ;message length

   mov    ecx,sum                       ;message to write

   mov    ebx,1             ;file descriptor (stdout)

   mov    eax,4             ;system call number (sys_write)

   int       0x80               ;call kernel               

   mov    eax,1             ;system call number (sys_exit)

   int       0x80               ;call kernel

section .data

msg db 'The Sum is:',0xa              

len equ $ - msg                                

num1 db '12345'

num2 db '23456'

sum db '     '

OUTPUT:

The Sum is:

35801

Strings in Assembly

The variable length strings can have as many characters as required. Generally, we specify the length of the string by either of the two ways:

1. Explicitly storing string length
2. Using a sentinel character

We can store the string length explicitly by using the $ location counter symbol that represents the current value of the location counter. In the following example:

msg  db  ‘Hello, world!’,0xa ;our dear string

len  equ  $ – msg            ;length of our dear string

$ points to the byte after the last character of the string variable msg. Therefore, $-msg gives the length of the string. We can also write:

msg db ‘Hello, world!’,0xa ;our dear string

len equ 13                 ;length of our dear string

Alternatively, you can store strings with a trailing sentinel character to delimit a string instead of storing the string length explicitly. For example:

message DB ‘I am loving it!’, 0

String Instructions

Each string instruction may require a source operand, a destination operand or both. For 32-bit segments, string instructions use ESI and EDI registers to point to the source and destination operands, respectively. For 16-bit segments, But, the SI and the DI registers are used to point to the source and destination, respectively. There are five basic instructions for processing strings. They are:

1. MOVS: This instruction moves 1 Byte, Word or Doubleword of data from memory location to another.
2. LODS: This instruction loads from memory. If the operand is of one byte, it is loaded into the AL register, if the operand is one word, it is loaded into the AX register and a doubleword is loaded into the EAX register.
3. STOS: This instruction stores data from register (AL, AX, or EAX) to memory.
4. CMPS: This instruction compares two data items in memory. Data could be of a byte size, word or doubleword.
5. SCAS: This instruction compares the contents of a register (AL, AX or EAX) with the contents of an item in memory.

Each of the above instruction has a byte, word, and doubleword version, and string instructions can be repeated by using a repetition prefix.

These instructions use the ES: DI and DS:SI pair of registers, where DI and SI registers contain valid offset addresses that refers to bytes stored in memory. SI is normally associated with DS (data segment) and DI is always associated with ES (extra segment).

The DS:SI (or ESI) and ES:DI (or EDI) registers point to the source and destination operands, respectively. The source operand is assumed to be at DS:SI (or ESI) and the destination operand at ES:DI (or EDI) in memory.

For 16-bit addresses, the SI and DI registers are used, and for 32-bit addresses, the ESI and EDI registers are used.

Repetition Prefixes

The REP prefix, when set before a string instruction, for example – REP MOVSB, causes repetition of the instruction based on a counter placed at the CX register. REP executes the instruction, decreases CX by 1, and checks whether CX is zero. It repeats the instruction processing until CX is zero.

• The Direction Flag (DF) determines the direction of the operation.
• Use CLD (Clear Direction Flag, DF = 0) to make the operation left to right.
• Use STD (Set Direction Flag, DF = 1) to make the operation right to left.

The REP prefix also has the following variations:

REP: It is the unconditional repeat. It repeats the operation until CX is zero.

REPE or REPZ: It is conditional repeat. It repeats the operation while the zero flag indicates equal/zero. It stops when the ZF indicates not equal/zero or when CX is zero.

REPNE or REPNZ: It is also conditional repeat. It repeats the operation while the zero flag indicates not equal/zero. It stops when the ZF indicates equal/zero or when CX is decremented to zero.

Arrays in Assembly

The data definition directives to the assembler are used for allocating storage for variables. The variable could  be initialized with some specific value. The initialized value could be specified in hexadecimal, decimal or binary form. For example, we can define a word variable ‘months’ in either of the following way:

MONTHS             DW         12

MONTHS             DW         0CH

MONTHS             DW         0110B

The data definition directives can also be used for defining a one-dimensional array. Let us define a one-dimensional array of numbers.

NUMBERS           DW  34,  45,  56,  67,  75, 89

The above definition declares an array of six words each initialized with the numbers 34, 45, 56, 67, 75, 89. This allocates 2×6 = 12 bytes of consecutive memory space. The symbolic address of the first number will be NUMBERS and that of the second number will be NUMBERS + 2 and so on. Let us take up another example. You can define an array named inventory of size 8, and initialize all the values with zero, as :

INVENTORY   DW  0

            DW  0

            DW  0

            DW  0

            DW  0

            DW  0

            DW  0

            DW  0

Which can be abbreviated as:

INVENTORY   DW  0, 0 , 0 , 0 , 0 , 0 , 0 , 0

The TIMES directive can also be used for multiple initializations to the same value. Using TIMES, the INVENTORY array can be defined as:

INVENTORY TIMES 8 DW 0

Example

The following example demonstrates the above concepts by defining a 3-element array x, which stores three values: 2, 3 and 4. It adds the values in the array and displays the sum 9:

section .text

   global _start   ;must be declared for linker (ld)               

_start:                                

   mov  eax,3      ;number bytes to be summed

   mov  ebx,0      ;EBX will store the sum

   mov  ecx, x     ;ECX will point to the current element to be summed

top:  add  ebx, [ecx]

   add  ecx,1      ;move pointer to next element

   dec  eax        ;decrement counter

   jnz  top        ;if counter not 0, then loop again

done:

   add   ebx, '0'

   mov  [sum], ebx ;done, store result in "sum"

display:

   mov  edx,1      ;message length

   mov  ecx, sum   ;message to write

   mov  ebx, 1     ;file descriptor (stdout)

   mov  eax, 4     ;system call number (sys_write)

   int  0x80       ;call kernel               

   mov  eax, 1     ;system call number (sys_exit)

   int  0x80       ;call kernel

section .data

global x

x:   

   db  2

   db  4

   db  3

sum:

   db  0

OUTPUT:

9

Part 6: Arithmetic Instructions in Assembly Language

by Jesmin Akther | Jul 1, 2021 | Assembly Language

Arithmetic Instructions in Assembly Language

The INC Instruction

The INC instruction is used for incrementing an operand by one. It works on a single operand that can be either in a register or in memory.

Syntax

The INC instruction has the following syntax

INC destination

The operand destination could be an 8-bit, 16-bit or 32-bit operand. Example

INC EBX      ; Increments 32-bit register

INC DL       ; Increments 8-bit register

INC [count]  ; Increments the count variable

The DEC Instruction

The DEC instruction is used for decrementing an operand by one. It works on a single operand that can be either in a register or in memory.

Syntex:

DEC destination

ADD and SUB Instructions

The ADD and SUB instructions are used for performing simple addition/subtraction of binary data in byte, word and doubleword size. For example, adding or subtracting 8-bit, 16-bit or 32-bit operands, respectively.

Syntex:

ADD/SUB	destination, source

The ADD/SUB instruction can take place between: Register, Memory and constant data But, like other instructions, memory-to-memory operations are not possible using ADD/SUB instructions. An ADD or SUB operation sets or clears the overflow and carry flags.

Example

The following example will ask two digits from the user, store the digits in the EAX and EBX register, respectively, add the values, store the result in a memory location ‘res’ and finally display the result.

SYS_EXIT  equ 1
SYS_READ  equ 3
SYS_WRITE equ 4
STDIN     equ 0
STDOUT    equ 1

segment .data 

   msg1 db "Enter a digit ", 0xA,0xD 
   len1 equ $- msg1 

   msg2 db "Please enter a second digit", 0xA,0xD 
   len2 equ $- msg2 

   msg3 db "The sum is: "
   len3 equ $- msg3

segment .bss

   num1 resb 2 
   num2 resb 2 
   res resb 1    

section	.text
   global _start    ;must be declared for using gcc
	
_start:             ;tell linker entry point
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg1         
   mov edx, len1 
   int 0x80                

   mov eax, SYS_READ 
   mov ebx, STDIN  
   mov ecx, num1 
   mov edx, 2
   int 0x80            

   mov eax, SYS_WRITE        
   mov ebx, STDOUT         
   mov ecx, msg2          
   mov edx, len2         
   int 0x80

   mov eax, SYS_READ  
   mov ebx, STDIN  
   mov ecx, num2 
   mov edx, 2
   int 0x80        

   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg3          
   mov edx, len3         
   int 0x80

   ; moving the first number to eax register and second number to ebx
   ; and subtracting ascii '0' to convert it into a decimal number
	
   mov eax, [num1]
   sub eax, '0'
	
   mov ebx, [num2]
   sub ebx, '0'

   ; add eax and ebx
   add eax, ebx
   ; add '0' to to convert the sum from decimal to ASCII
   add eax, '0'

   ; storing the sum in memory location res
   mov [res], eax

   ; print the sum 
   mov eax, SYS_WRITE        
   mov ebx, STDOUT
   mov ecx, res         
   mov edx, 1        
   int 0x80

exit:    
   
   mov eax, SYS_EXIT   
   xor ebx, ebx 
   int 0x80

OUTPUT:

Enter a digit:
3
Please enter a second digit:
4
The sum is:
7

The MUL or IMUL Instruction

T

here are two instructions for multiplying binary data. The MUL (Multiply) instruction handles unsigned data and the IMUL (Integer Multiply) handles signed data. Both instructions affect the Carry and Overflow flag.

Syntax

MUL/IMUL multiplier

Example The following example multiplies 3 with 2, and displays the result −

section	.text
   global _start    ;must be declared for using gcc
  
_start:             ;tell linker entry point

   mov	al,'3'
   sub     al, '0'
  
   mov 	bl, '2'
   sub     bl, '0'
   mul 	bl
   add	al, '0'
  
   mov 	[res], al
   mov	ecx,msg	
   mov	edx, len
   mov	ebx,1	;file descriptor (stdout)
   mov	eax,4	;system call number (sys_write)
   int	0x80	;call kernel
  
   mov	ecx,res
   mov	edx, 1
   mov	ebx,1	;file descriptor (stdout)
   mov	eax,4	;system call number (sys_write)
   int	0x80	;call kernel
  
   mov	eax,1	;system call number (sys_exit)
   int	0x80	;call kernel

section .data
msg db "The result is:", 0xA,0xD 
len equ $- msg   
segment .bss
res resb 1

OUTPUT

The result is:
6

The DIV/IDIV Instructions

The division operation generates two elements, a quotient and a remainder. In case of multiplication, overflow does not occur because double-length registers are used to keep the product. However, in case of division, overflow may occur. The processor generates an interrupt if overflow occurs. The DIV (Divide) instruction is used for unsigned data and the IDIV (Integer Divide) is used for signed data.

Syntax: DIV/IDIV              divisor

The dividend is in an accumulator. Both the instructions can work with 8-bit, 16-bit or 32-bit operands. The operation affects all six status flags. Following section explains three cases of division with different operand sizes.

section	.text
   global _start    ;must be declared for using gcc
  
_start:             ;tell linker entry point
   mov	ax,'8'
   sub     ax, '0'
  
   mov 	bl, '2'
   sub     bl, '0'
   div 	bl
   add	ax, '0'
  
   mov 	[res], ax
   mov	ecx,msg	
   mov	edx, len
   mov	ebx,1	;file descriptor (stdout)
   mov	eax,4	;system call number (sys_write)
   int	0x80	;call kernel
  
   mov	ecx,res
   mov	edx, 1
   mov	ebx,1	;file descriptor (stdout)
   mov	eax,4	;system call number (sys_write)
   int	0x80	;call kernel
  
   mov	eax,1	;system call number (sys_exit)
   int	0x80	;call kernel
  
section .data
msg db "The result is:", 0xA,0xD 
len equ $- msg   
segment .bss
res resb 1

OUTPUT:
4