Conditions and Loop with code in Assembly

Conditional run in assembly language is accompanied by many  looping and branching instructions. Firstly we discuss here with conditions in assembly then the loops in Assembly.

Conditions in Assembly

Conditional execution in assembly language is accomplished by several looping and branching instructions. These instructions can change the flow of control in a program. Conditional execution is observed in two scenarios:

1. Unconditional jump

This is performed by the JMP instruction. Conditional execution often involves a transfer of control to the address of an instruction that does not follow the currently executing instruction. Transfer of control may be forward, to execute a new set of instructions or backward, to re-execute the same steps.

 2. Conditional jump

This is performed by a set of jump instructions j<condition> depending upon the condition. The conditional instructions transfer the control by breaking the sequential flow and they do it by changing the offset value in IP.

Unconditional Jump

This is performed by the JMP instruction. Conditional execution often involves a transfer of control to the address of an instruction that does not follow the currently executing instruction. Transfer of control may be forward, to execute a new set of instructions or backward, to re-execute the same steps.

Syntax

The JMP instruction provides a label name where the flow of control is transferred immediately. The syntax of the JMP instruction is:

Example

MOV  AX, 00    ; Initializing AX to 0

MOV  BX, 00    ; Initializing BX to 0

MOV  CX, 01    ; Initializing CX to 1

L20:

ADD  AX, 01    ; Increment AX

ADD  BX, AX    ; Add AX to BX

SHL  CX, 1     ; shift left CX, this in turn doubles the CX value

JMP  L20       ; repeats the statements

Conditional Jump

If some specified condition is satisfied in conditional jump, the control flow is transferred to a target instruction. There are numerous conditional jump instructions depending upon the condition and data. The syntax for the J<condition> set of instructions.

Example:

CMP      AL, BL

JE       EQUAL

CMP      AL, BH

JE       EQUAL

CMP      AL, CL

JE       EQUAL

NON_EQUAL: ...

EQUAL: ...

Example

The following program displays the largest of three variables. The variables are double-digit variables. The three variables num1, num2 and num3 have values 47, 22 and 31, respectively:

section .text

   global _start         ;must be declared for using gcc

_start:                    ;tell linker entry point

   mov   ecx, [num1]

   cmp   ecx, [num2]

   jg    check_third_num
   mov   ecx, [num2]

                check_third_num:

   cmp   ecx, [num3]

   jg    _exit

   mov   ecx, [num3]  

                _exit:  

   mov   [largest], ecx

   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,largest

   mov   edx, 2

   mov   ebx,1     ;file descriptor (stdout)

   mov   eax,4      ;system call number (sys_write)

   int   0x80           ;call kernel   

   mov   eax, 1

   int   80h

section .data

   msg db "The largest digit is: ", 0xA,0xD

   len equ $- msg

   num1 dd '47'

   num2 dd '22'

   num3 dd '31'

segment .bss

   largest resb 2

OUTPUT:

The largest digit is:

47

Loop uses in Assembly

The JMP instruction can be used for implementing loops. For example, the following code snippet can be used for executing the loop-body 10 times.

MOV     CL, 10

L1:

<LOOP-BODY>

DEC        CL

JNZ         L1

The processor instruction set, however, includes a group of loop instructions for implementing iteration. The basic LOOP instruction has the following syntax :

LOOP     label

Where, label is the target label that identifies the target instruction as in the jump instructions. The LOOP instruction assumes that the ECX register contains the loop count. When the loop instruction is executed, the ECX register is decremented and the control jumps to the target label, until the ECX register value, i.e., the counter reaches the value zero. The above code snippet could be written as:

mov ECX,10

l1:

<loop body>

loop l1

Example

The following program prints the number 1 to 9 on the screen:

section .text

   global _start        ;must be declared for using gcc               

_start:                   ;tell linker entry point

   mov ecx,10
   mov eax, '1'               

l1:

   mov [num], eax

   mov eax, 4

   mov ebx, 1

   push ecx               

   mov ecx, num       

   mov edx, 1       

   int 0x80               

   mov eax, [num]

   sub eax, '0'

   inc eax

   add eax, '0'

   pop ecx

   loop l1               

   mov eax,1             ;system call number (sys_exit)

   int 0x80              ;call kernel

section .bss

num resb 1

OUTPUT

123456789: