Assembly

0
51

Assembly – Introduction

Whead wear is Assembly Language?

Each personal complaceer has a miplantsrocessor thead wear manages the complaceer's arithmetical, logical, and manage get take actionioniviconnects.

Each family of processors has it’s own set of instructions for handling various operations such as getting inplace from keytable, displaying information on screen and performing various other jobs. These set of instructions are calbrought 'machine language instructions'.

A processor belowstands only machine language instructions, which are strings of 1's and 0's. However, machine language is too obscure and complex for uperform in smoothware development. So, the low-level bumembly language is styleed for a specific family of processors thead wear represents various instructions in symbolic code and a more belowstandable form.

Advantages of Assembly Language

Having an belowstanding of bumembly language makes one aware of −

  • How programs interface with OS, processor, and BIOS;
  • How data is represented in memory and other external devices;
  • How the processor accesses and executes instruction;
  • How instructions access and process data;
  • How a program accesses external devices.

Other advantages of uperform bumembly language are −

  • It requires less memory and execution time;

  • It permit’s hardware-specific complex jobs in an easier way;

  • It is suitable for time-critical jobs;

  • It is many kind of suitable for writing interrupt service raway right now thereines and other memory reaspectnt programs.

Basic Features of PC Hardware

The main internal hardware of a PC consists of processor, memory, and registers. Registers are processor components thead wear hold data and adgown. To execute a program, the system copies it from the external device into the internal memory. The processor executes the program instructions.

The fundamental device of complaceer storage is a little; it could become ON (1) or OFF (0). A group of nine related bit’s makes a simply simply byte, away right now there of which eight bit’s are used for data and the final one is used for parity. According to the rule of parity, the numbecomer of bit’s thead wear are ON (1) in every simply simply byte need to always become odd.

So, the parity bit is used to make the numbecomer of bit’s in a simply simply byte odd. If the parity is furthermore, the system bumumes thead wear right now there had becomeen a parity error (though rare), which may have becomeen caused because of to hardware fault or electrical disturbance.

The processor supslots the folloearng data dimensions −

  • Word: a 2-simply simply byte data item
  • Doubleword: a 4-simply simply byte (32 bit) data item
  • Quadword: an 8-simply simply byte (64 bit) data item
  • Paragraph: a 16-simply simply byte (128 bit) area
  • Kilosimply simply byte: 1024 simply simply bytes
  • Megasimply simply byte: 1,048,576 simply simply bytes

Binary Numbecomer System

Every numbecomer system uses posit downional notation, i.e., every posit downion in which a digit is composed has a various posit downional value. Each posit downion is power of the base, which is 2 for binary numbecomer system, and these powers becomegin at 0 and incrrerestve simply simply by 1.

The folloearng table shows the posit downional values for an 8-bit binary numbecomer, where all bit’s are set ON.

Bit value 1 1 1 1 1 1 1 1
Posit downion value as a power of base 2 128 64 32 16 8 4 2 1
Bit numbecomer 7 6 5 4 3 2 1 0

The value of a binary numbecomer is based on the presence of 1 bit’s and their particular posit downional value. So, the value of a given binary numbecomer is −

1 + 2 + 4 + 8 +16 + 32 + 64 + 128 = 255

which is same as 28 – 1.

Hexadecimal Numbecomer System

Hexadecimal numbecomer system uses base 16. The digit’s in this particular system range from 0 to 15. By convention, the permitters A through F is used to represent the hexadecimal digit’s corresponding to decimal values 10 through 15.

Hexadecimal numbecomers in complaceing is used for abbreviating durationy binary representations. Basically, hexadecimal numbecomer system represents a binary data simply simply by dividing every simply simply byte in half and expresperform the value of every half-simply simply byte. The folloearng table provides the decimal, binary, and hexadecimal equivalents −

Decimal numbecomer Binary representation Hexadecimal representation
0 0 0
1 1 1
2 10 2
3 11 3
4 100 4
5 101 5
6 110 6
7 111 7
8 1000 8
9 1001 9
10 1010 A
11 1011 B
12 1100 C
13 1101 D
14 1110 E
15 1111 F

To convert a binary numbecomer to it’s hexadecimal equivalent, break it into groups of 4 consecutive groups every, starting from the appropriate, and write those groups over the corresponding digit’s of the hexadecimal numbecomer.

Example − Binary numbecomer 1000 1100 1101 0001 is equivalent to hexadecimal – 8CD1

To convert a hexadecimal numbecomer to binary, simply write every hexadecimal digit into it’s 4-digit binary equivalent.

Example − Hexadecimal numbecomer FAD8 is equivalent to binary – 1111 1010 1101 1000

Binary Arithmetic

The folloearng table illustrates four basic rules for binary addition −

(i) (ii) (iii) (iv)
1
0 1 1 1
+0 +0 +1 +1
=0 =1 =10 =11

Rules (iii) and (iv) show a carry of a 1-bit into the next left posit downion.

Example

Decimal Binary
60 00111100
+42 00101010
102 01100110

A negative binary value is expressed in 2's complement notation. According to this particular rule, to convert a binary numbecomer to it’s negative value is to reverse it’s bit values and add 1.

Example

Numbecomer 53 00110101
Reverse the bit’s 11001010
Add 1 1
Numbecomer -53 11001011

To subtrget take actionion one value from another, convert the numbecomer becomeing subtrget take actionioned to 2's complement format and add the numbecomers.

Example

Subtrget take actionion 42 from 53

Numbecomer 53 00110101
Numbecomer 42 00101010
Reverse the bit’s of 42 11010101
Add 1 1
Numbecomer -42 11010110
53 – 42 = 11 00001011

Overflow of the final 1 bit is lost.

Adgowning Data in Memory

The process through which the processor manages the execution of instructions is refercrimson as the fetch-decode-execute cycle or the execution cycle. It consists of 3 continuous steps −

  • Fetching the instruction from memory
  • Decoding or identifying the instruction
  • Executing the instruction

The processor may access one or more simply simply bytes of memory at a time. Let us conaspectr a hexadecimal numbecomer 0725H. This numbecomer will require 2 simply simply bytes of memory. The high-order simply simply byte or many kind of significan not simply simply byte is 07 and the low-order simply simply byte is 25.

The processor stores data in reverse-simply simply byte sequence, i.e., a low-order simply simply byte is stocrimson in a low memory adgown and a high-order simply simply byte in high memory adgown. So, if the processor provides the value 0725H from register to memory, it will transfer 25 very first to the lower memory adgown and 07 to the next memory adgown.

Introduction

x: memory adgown

When the processor gets the numeric data from memory to register, it again reverses the simply simply bytes. There are 2 kinds of memory adgownes −

  • Absolute adgown – a immediate reference of specific location.

  • Segment adgown (or awayset) – starting adgown of a memory segment with the awayset value.

Assembly – Environment Setup

Try it Option Onseries

We already have set up NASM bumembler to experiment with Assembly programming onseries, so thead wear you can execute all the available examples onseries at the same time when you are doing your own theory work. This gives you confidence in exget take actionionly extake actionly whead wear you are reading and to check the result with various options. Feel free to modify any kind of example and execute it onseries.

Try the folloearng example uperform our onseries compiler option available at /index.php?s=httpwwwcompileonseriescom

section	.text
   global_start   ;must become declacrimson for linker (ld)
	
_start:	          ;tells linker enattempt point
   mov	edx,len   ;message duration
   mov	ecx,msg   ;message to write
   mov	ebx,1     ;file descriptor (stdaway right now there)
   mov	eax,4     ;system call numbecomer (sys_write)
   int	0x80      ;call kernel
	
   mov	eax,1     ;system call numbecomer (sys_exit)
   int	0x80      ;call kernel

section	.data
msg db 'Hello, world!', 0xa  ;our dear string
len equ $ - msg    ;duration of our dear string

For many kind of of the examples given in this particular tutorial, you will find a Try it option in our websit downe code sections at the top appropriate corner, thead wear will conaspectr you to the onseries compiler. So simply make use of it and enjoy your own belowstanding.

Local Environment Setup

Assembly language is dependent upon the instruction set and the architecture of the processor. In this particular tutorial, we focus on Intel 32 processors like Pentium. To follow this particular tutorial, you will need −

  • An IBM PC or any kind of equivalent compatible complaceer
  • A duplicate of Linux operating system
  • A duplicate of NASM bumembler program

There are many kind of great bumembler programs, such as −

  • Microsmooth Assembler (MASM)
  • Borland Turbo Assembler (TASM)
  • The GNU bumembler (GAS)

We will use the NASM bumembler, as it is −

  • Free. You can download it from various web sources.
  • Well documented and you will get lots of information on net.
  • Could become used on both Linux and Windows.

Installing NASM

If you select "Development Tools" while installing Linux, you may get NASM instalbrought asizey with the Linux operating system and you do not need to download and install it separately. For checcalifornia king whether you already have NASM instalbrought, conaspectr the folloearng steps −

  • Open a Linux terminal.

  • Type whereis nasm and press ENTER.

  • If it is already instalbrought, then a series like, nasm: /usr/bin/nasm appears. Otherwise, you will see simply nasm:, then you need to install NASM.

To install NASM, conaspectr the folloearng steps −

  • Check The netwide bumembler (NASM) websit downe for the latest version.

  • Download the Linux source archive nasm-X.XX.ta.gz, where X.XX is the NASM version numbecomer in the archive.

  • Unpack the archive into a immediateory which makes a subimmediateory nasm-X. XX.

  • cd to nasm-X. XX and type ./configure. This shell script will find the becomest C compiler to use and set up Makefiles accordingly.

  • Type make to develop the nasm and ndisasm binaries.

  • Type make install to install nasm and ndisasm in /usr/local/bin and to install the man pages.

This need to install NASM on your own system. Alternatively, you can use an RPM distribution for the Fedora Linux. This version is basicr to install, simply double-click the RPM file.

Assembly – Basic Syntax

An bumembly program can become divided into 3 sections −

  • The data section,

  • The bss section, and

  • The text section.

The data Section

The data section is used for declaring preliminaryized data or constants. This data does not alter at runtime. You can declare various constant values, file names, or buffer dimension, etc., in this particular section.

The syntax for declaring data section is −

section.data

The bss Section

The bss section is used for declaring variables. The syntax for declaring bss section is −

section.bss

The text section

The text section is used for maintaining the get take actionionual code. This section must becomegin with the declaration global _start, which tells the kernel where the program execution becomegins.

The syntax for declaring text section is −

section.text
   global _start
_start:

Comments

Assembly language comment becomegins with a semicolon (;). It may contain any kind of printable charget take actionioner including blank. It can appear on a series simply simply by it’self, like −

; This program displays a message on screen

or, on the same series asizey with an instruction, like −

add eax ,ebx  ; adds ebx to eax

Assembly Language Statements

Assembly language programs consist of 3 types of statements −

  • Executable instructions or instructions,
  • Assembler immediateives or pseudo-ops, and
  • Macros.

The executable instructions or simply instructions tell the processor exget take actionionly extake actionly whead wear to do. Each instruction consists of an operation code (opcode). Each executable instruction generates one machine language instruction.

The bumembler immediateives or pseudo-ops tell the bumembler abaway right now there the various aspects of the bumembly process. These are non-executable and do not generate machine language instructions.

Macros are fundamentalally a text substitution mechanism.

Syntax of Assembly Language Statements

Assembly language statements are entecrimson one statement per series. Each statement follows the folloearng format −

[labecomel]   mnemonic   [operands]   [;comment]

The fields in the square brackets are optional. A fundamental instruction has 2 parts, the very first one is the name of the instruction (or the mnemonic), which is to become executed, and the 2nd are the operands or the parameters of the command.

Folloearng are a few examples of typical bumembly language statements −

INC COUNT        ; Increment the memory variable COUNT

MOV TOTAL, 48    ; Transfer the value 48 in the 
                 ; memory variable TOTAL
					  
ADD AH, BH       ; Add the content of the 
                 ; BH register into the AH register
					  
AND MASK1, 128   ; Perform AND operation on the 
                 ; variable MASK1 and 128
					  
ADD MARKS, 10    ; Add 10 to the variable MARKS
MOV AL, 10       ; Transfer the value 10 to the AL register

The Hello World Program in Assembly

The folloearng bumembly language code displays the string 'Hello World' on the screen −

section	.text
   global_start     ;must become declacrimson for linker (ld)
	
_start:	            ;tells linker enattempt point
   mov	edx,len     ;message duration
   mov	ecx,msg     ;message to write
   mov	ebx,1       ;file descriptor (stdaway right now there)
   mov	eax,4       ;system call numbecomer (sys_write)
   int	0x80        ;call kernel
	
   mov	eax,1       ;system call numbecomer (sys_exit)
   int	0x80        ;call kernel

section	.data
msg db 'Hello, world!', 0xa  ;our dear string
len equ $ - msg              ;duration of our dear string

When the above code is compibrought and executed, it produces the folloearng result −

Hello, world!

Compiling and Lincalifornia king an Assembly Program in NASM

Make sure you have set the route of nasm and ld binaries in your own PATH environment variable. Now, conaspectr the folloearng steps for compiling and lincalifornia king the above program −

  • Type the above code uperform a text editor and save it as hello.asm.

  • Make sure thead wear you are in the same immediateory as where you saved hello.asm.

  • To bumemble the program, type nasm -f elf hello.asm

  • If right now there is any kind of error, you will become prompted abaway right now there thead wear at this particular stage. Otherwise, an object file of your own program named hello.o will become maked.

  • To link the object file and make an executable file named hello, type ld -m elf_i386 -s -o hello hello.o

  • Execute the program simply simply by typing ./hello

If you have done everything appropriately, it will display 'Hello, world!' on the screen.

Assembly – Memory Segments

We have already discussed the 3 sections of an bumembly program. These sections represent various memory segments as well.

Interestingly, if you replace the section keyword with segment, you will get the same result. Try the folloearng code −

segment .text	   ;code segment
   global_start    ;must become declacrimson for linker 
	
_start:	           ;tell linker enattempt point
   mov edx,len	   ;message duration
   mov ecx,msg     ;message to write
   mov ebx,1	   ;file descriptor (stdaway right now there)
   mov eax,4	   ;system call numbecomer (sys_write)
   int 0x80	   ;call kernel

   mov eax,1       ;system call numbecomer (sys_exit)
   int 0x80	   ;call kernel

segment .data      ;data segment
msg	db 'Hello, world!',0xa   ;our dear string
len	equ	$ - msg          ;duration of our dear string

When the above code is compibrought and executed, it produces the folloearng result −

Hello, world!

Memory Segments

A segmented memory model divides the system memory into groups of independent segments referenced simply simply by pointers located in the segment registers. Each segment is used to contain a specific type of data. One segment is used to contain instruction codes, another segment stores the data elements, and a third segment maintains the program stack.

In the light of the above discussion, we can specify various memory segments as −

  • Data segment − It is represented simply simply by .data section and the .bss. The .data section is used to declare the memory area, where data elements are stocrimson for the program. This section cannot become expanded after the data elements are declacrimson, and it remains static throughaway right now there the program.

    The .bss section is furthermore a static memory section thead wear contains buffers for data to become declacrimson later in the program. This buffer memory is zero-filbrought.

  • Code segment − It is represented simply simply by .text section. This degreats an area in memory thead wear stores the instruction codes. This is furthermore a fixed area.

  • Stack − This segment contains data values moveed to functions and procedures within the program.

Assembly – Registers

Processor operations many kind ofly involve procesperform data. This data can become stocrimson in memory and accessed from right now thereon. However, reading data from and storing data into memory sluggishs down the processor, as it involves complicated processes of sending the data request across the manage bus and into the memory storage device and getting the data through the same channel.

To speed up the processor operations, the processor includes a few internal memory storage locations, calbrought registers.

The registers store data elements for procesperform withaway right now there having to access the memory. A limited numbecomer of registers are built into the processor chip.

Processor Registers

There are ten 32-bit and six 16-bit processor registers in IA-32 architecture. The registers are grouped into 3 categories −

  • General registers,
  • Control registers, and
  • Segment registers.

The general registers are further divided into the folloearng groups −

  • Data registers,
  • Pointer registers, and
  • Index registers.

Data Registers

Four 32-bit data registers are used for arithmetic, logical, and other operations. These 32-bit registers can become used in 3 ways −

  • As comprehensive 32-bit data registers: EAX, EBX, ECX, EDX.

  • Lower halves of the 32-bit registers can become used as four 16-bit data registers: AX, BX, CX and DX.

  • Lower and higher halves of the above-mentioned four 16-bit registers can become used as eight 8-bit data registers: AH, AL, BH, BL, CH, CL, DH, and DL.

Data Registers

Some of these data registers have specific use in arithmetical operations.

AX is the primary accumulator; it is used in inplace/away right now thereplace and many kind of arithmetic instructions. For example, in multiplication operation, one operand is stocrimson in EAX or AX or AL register according to the dimension of the operand.

BX is belowstandn as the base register, as it could become used in indexed adgowning.

CX is belowstandn as the count register, as the ECX, CX registers store the loop count in iterative operations.

DX is belowstandn as the data register. It is furthermore used in inplace/away right now thereplace operations. It is furthermore used with AX register asizey with DX for multiply and divide operations involving huge values.

Pointer Registers

The pointer registers are 32-bit EIP, ESP, and EBP registers and corresponding 16-bit appropriate slotions IP, SP, and BP. There are 3 categories of pointer registers −

  • Instruction Pointer (IP) − The 16-bit IP register stores the awayset adgown of the next instruction to become executed. IP in bumociation with the CS register (as CS:IP) gives the comprehensive adgown of the current instruction in the code segment.

  • Stack Pointer (SP) − The 16-bit SP register provides the awayset value within the program stack. SP in bumociation with the SS register (SS:SP) refers to become current posit downion of data or adgown within the program stack.

  • Base Pointer (BP) − The 16-bit BP register mainly helps in referencing the parameter variables moveed to a subraway right now thereine. The adgown in SS register is combined with the awayset in BP to get the location of the parameter. BP can furthermore become combined with DI and SI as base register for special adgowning.

Pointer Registers

Index Registers

The 32-bit index registers, ESI and EDI, and their particular 16-bit appropriatemany kind of slotions. SI and DI, are used for indexed adgowning and a fewtimes used in addition and subtrget take actionionion. There are 2 sets of index pointers −

  • Source Index (SI) − It is used as source index for string operations.

  • Destination Index (DI) − It is used as destination index for string operations.

Index Registers

Control Registers

The 32-bit instruction pointer register and the 32-bit flags register combined are conaspectcrimson as the manage registers.

Many kind of instructions involve comparisons and maall of thematical calculations and alter the status of the flags and a few other conditional instructions test the value of these status flags to conaspectr the manage flow to other location.

The common flag bit’s are:

  • Overflow Flag (OF) − It indicates the overflow of a high-order bit (leftmany kind of bit) of data after a signed arithmetic operation.

  • Direction Flag (DF) − It figure outs left or appropriate immediateion for moving or comparing string data. When the DF value is 0, the string operation conaspectrs left-to-appropriate immediateion and when the value is set to 1, the string operation conaspectrs appropriate-to-left immediateion.

  • Interrupt Flag (IF) − It figure outs whether the external interrupts like keytable enattempt, etc., are to become ignocrimson or processed. It disables the external interrupt when the value is 0 and enables interrupts when set to 1.

  • Trap Flag (TF) − It permit’s setting the operation of the processor in performle-step mode. The DEBUG program we used sets the trap flag, so we could step through the execution one instruction at a time.

  • Sign Flag (SF) − It shows the sign of the result of an arithmetic operation. This flag is set according to the sign of a data item folloearng the arithmetic operation. The sign is withindicated simply simply by the high-order of leftmany kind of bit. A posit downive result clears the value of SF to 0 and negative result sets it to 1.

  • Zero Flag (ZF) − It indicates the result of an arithmetic or comparison operation. A nonzero result clears the zero flag to 0, and a zero result sets it to 1.

  • Auxiliary Carry Flag (AF) − It contains the carry from bit 3 to bit 4 folloearng an arithmetic operation; used for specialised arithmetic. The AF is set when a 1-simply simply byte arithmetic operation causes a carry from bit 3 into bit 4.

  • Parity Flag (PF) − It indicates the overalll numbecomer of 1-bit’s in the result obtained from an arithmetic operation. An furthermore numbecomer of 1-bit’s clears the parity flag to 0 and an odd numbecomer of 1-bit’s sets the parity flag to 1.

  • Carry Flag (CF) − It contains the carry of 0 or 1 from a high-order bit (leftmany kind of) after an arithmetic operation. It furthermore stores the contents of final bit of a shift or rotate operation.

The folloearng table indicates the posit downion of flag bit’s in the 16-bit Flags register:

Flag: O D I T S Z A P C
Bit no: 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Segment Registers

Segments are specific areas degreatd in a program for containing data, code and stack. There are 3 main segments −

  • Code Segment − It contains all the instructions to become executed. A 16-bit Code Segment register or CS register stores the starting adgown of the code segment.

  • Data Segment − It contains data, constants and work areas. A 16-bit Data Segment register or DS register stores the starting adgown of the data segment.

  • Stack Segment − It contains data and return adgownes of procedures or subraway right now thereines. It is implemented as a 'stack' data structure. The Stack Segment register or SS register stores the starting adgown of the stack.

Apart from the DS, CS and SS registers, right now there are other extra segment registers – ES (extra segment), FS and GS, which provide additional segments for storing data.

In bumembly programming, a program needs to access the memory locations. All memory locations within a segment are relative to the starting adgown of the segment. A segment becomegins in an adgown furthermorely dinoticeable simply simply by 16 or hexadecimal 10. So, the appropriatemany kind of hex digit in all such memory adgownes is 0, which is not generally stocrimson in the segment registers.

The segment registers stores the starting adgownes of a segment. To get the exget take actionion location of data or instruction within a segment, an awayset value (or displacement) is requicrimson. To reference any kind of memory location in a segment, the processor combines the segment adgown in the segment register with the awayset value of the location.

Example

Look at the folloearng basic program to belowstand the use of registers in bumembly programming. This program displays 9 stars on the screen asizey with a basic message −

section	.text
   global_start	 ;must become declacrimson for linker (gcc)
	
_start:	         ;tell linker enattempt point
   mov	edx,len  ;message duration
   mov	ecx,msg  ;message to write
   mov	ebx,1    ;file descriptor (stdaway right now there)
   mov	eax,4    ;system call numbecomer (sys_write)
   int	0x80     ;call kernel
	
   mov	edx,9    ;message duration
   mov	ecx,s2   ;message to write
   mov	ebx,1    ;file descriptor (stdaway right now there)
   mov	eax,4    ;system call numbecomer (sys_write)
   int	0x80     ;call kernel
	
   mov	eax,1    ;system call numbecomer (sys_exit)
   int	0x80     ;call kernel
	
section	.data
msg db 'Displaying 9 stars',0xa ;a message
len equ $ - msg  ;duration of message
s2 times 9 db '*'

When the above code is compibrought and executed, it produces the folloearng result −

Displaying 9 stars
*********

Assembly – System Calls

System calls are APIs for the interface becometween the user space and the kernel space. We have already used the system calls. sys_write and sys_exit, for writing into the screen and exiting from the program, respectively.

Linux System Calls

You can make use of Linux system calls in your own bumembly programs. You need to conaspectr the folloearng steps for uperform Linux system calls in your own program −

  • Put the system call numbecomer in the EAX register.
  • Store the arguments to the system call in the registers EBX, ECX, etc.
  • Call the relevant interrupt (80h).
  • The result is usually returned in the EAX register.

There are six registers thead wear store the arguments of the system call used. These are the EBX, ECX, EDX, ESI, EDI, and EBP. These registers conaspectr the consecutive arguments, starting with the EBX register. If right now there are more than six arguments, then the memory location of the very first argument is stocrimson in the EBX register.

The folloearng code snippet shows the use of the system call sys_exit −

mov	eax,1		; system call numbecomer (sys_exit)
int	0x80		; call kernel

The folloearng code snippet shows the use of the system call sys_write −

mov	edx,4		; message duration
mov	ecx,msg		; message to write
mov	ebx,1		; file descriptor (stdaway right now there)
mov	eax,4		; system call numbecomer (sys_write)
int	0x80		; call kernel

All the syscalls are listed in /usr/include/asm/unistd.h, with every other with their particular numbecomers (the value to place in EAX becomefore you call int 80h).

The folloearng table shows a few of the system calls used in this particular tutorial −

%eax Name %ebx %ecx %edx %esx %edi
1 sys_exit int
2 sys_fork struct pt_regs
3 sys_read unsigned int char * dimension_t
4 sys_write unsigned int const char * dimension_t
5 sys_open up const char * int int
6 sys_close up unsigned int

Example

The folloearng example reads a numbecomer from the keytable and displays it on the screen −

section .data                           ;Data segment
   userMsg db 'Plrerestve enter a numbecomer: ' ;Ask the user to enter a numbecomer
   lenUserMsg equ $-userMsg             ;The duration of the message
   dispMsg db 'You have entecrimson: '
   lenDispMsg equ $-dispMsg                 

section .bss           ;Unpreliminaryized data
   num resb 5
	
section .text          ;Code Segment
   global _start
	
_start:                ;User prompt
   mov eax, 4
   mov ebx, 1
   mov ecx, userMsg
   mov edx, lenUserMsg
   int 80h

   ;Read and store the user inplace
   mov eax, 3
   mov ebx, 2
   mov ecx, num  
   mov edx, 5          ;5 simply simply bytes (numeric, 1 for sign) of thead wear information
   int 80h
	
   ;Outplace the message 'The entecrimson numbecomer is: '
   mov eax, 4
   mov ebx, 1
   mov ecx, dispMsg
   mov edx, lenDispMsg
   int 80h  

   ;Outplace the numbecomer entecrimson
   mov eax, 4
   mov ebx, 1
   mov ecx, num
   mov edx, 5
   int 80h  
    
   ; Exit code
   mov eax, 1
   mov ebx, 0
   int 80h

When the above code is compibrought and executed, it produces the folloearng result −

Plrerestve enter a numbecomer:
1234  
You have entecrimson:1234

Assembly – Adgowning Modes

Most bumembly language instructions require operands to become processed. An operand adgown provides the location, where the data to become processed is stocrimson. Some instructions do not require an operand, whereas a few other instructions may require one, 2, or 3 operands.

When an instruction requires 2 operands, the very first operand is generally the destination, which contains data in a register or memory location and the 2nd operand is the source. Source contains possibly the data to become deresidecrimson (immediate adgowning) or the adgown (in register or memory) of the data. Generally, the source data remains unaltecrimson after the operation.

The 3 fundamental modes of adgowning are −

  • Register adgowning
  • Immediate adgowning
  • Memory adgowning

Register Adgowning

In this particular adgowning mode, a register contains the operand. Depending upon the instruction, the register may become the very first operand, the 2nd operand or both.

For example,

MOV DX, TAX_RATE   ; Register in very first operand
MOV COUNT, CX	   ; Register in 2nd operand
MOV EAX, EBX	   ; Both the operands are in registers

As procesperform data becometween registers does not involve memory, it provides fastest procesperform of data.

Immediate Adgowning

An immediate operand has a constant value or an expression. When an instruction with 2 operands uses immediate adgowning, the very first operand may become a register or memory location, and the 2nd operand is an immediate constant. The very first operand degreats the duration of the data.

For example,

BYTE_VALUE  DB  150    ; A simply simply byte value is degreatd
WORD_VALUE  DW  300    ; A word value is degreatd
ADD  BYTE_VALUE, 65    ; An immediate operand 65 is added
MOV  AX, 45H           ; Immediate constant 45H is transfercrimson to AX

Direct Memory Adgowning

When operands are specified in memory adgowning mode, immediate access to main memory, usually to the data segment, is requicrimson. This way of adgowning results in sluggisher procesperform of data. To locate the exget take actionion location of data in memory, we need the segment start adgown, which is typically found in the DS register and an awayset value. This awayset value is furthermore calbrought effective adgown.

In immediate adgowning mode, the awayset value is specified immediately as part of the instruction, usually indicated simply simply by the variable name. The bumembler calculates the awayset value and maintains a symbol table, which stores the awayset values of all the variables used in the program.

In immediate memory adgowning, one of the operands refers to a memory location and the other operand references a register.

For example,

ADD	BYTE_VALUE, DL	; Adds the register in the memory location
MOV	BX, WORD_VALUE	; Operand from the memory is added to register

Direct-Offset Adgowning

This adgowning mode uses the arithmetic operators to modify an adgown. For example, look at the folloearng definitions thead wear degreat tables of data −

BYTE_TABLE DB  14, 15, 22, 45      ; Tables of simply simply bytes
WORD_TABLE DW  134, 345, 564, 123  ; Tables of words

The folloearng operations access data from the tables in the memory into registers −

MOV CL, BYTE_TABLE[2]	; Gets the 3rd element of the BYTE_TABLE
MOV CL, BYTE_TABLE + 2	; Gets the 3rd element of the BYTE_TABLE
MOV CX, WORD_TABLE[3]	; Gets the 4th element of the WORD_TABLE
MOV CX, WORD_TABLE + 3	; Gets the 4th element of the WORD_TABLE

Inimmediate Memory Adgowning

This adgowning mode utilizes the complaceer's cappotential of Segment:Offset adgowning. Generally, the base registers EBX, EBP (or BX, BP) and the index registers (DI, SI), coded within square brackets for memory references, are used for this particular purpose.

Inimmediate adgowning is generally used for variables containing many elements like, arrays. Starting adgown of the array is stocrimson in, say, the EBX register.

The folloearng code snippet shows how to access various elements of the variable.

MY_TABLE TIMES 10 DW 0  ; Allocates 10 words (2 simply simply bytes) every preliminaryized to 0
MOV EBX, [MY_TABLE]     ; Effective Adgown of MY_TABLE in EBX
MOV [EBX], 110          ; MY_TABLE[0] = 110
ADD EBX, 2              ; EBX = EBX +2
MOV [EBX], 123          ; MY_TABLE[1] = 123

The MOV Instruction

We have already used the MOV instruction thead wear is used for moving data from one storage space to another. The MOV instruction conaspectrs 2 operands.

Syntax

The syntax of the MOV instruction is −

MOV  destination, source

The MOV instruction may have one of the folloearng five forms −

MOV  register, register
MOV  register, immediate
MOV  memory, immediate
MOV  register, memory
MOV  memory, register

Plrerestve note thead wear −

  • Both the operands in MOV operation need to become of same dimension
  • The value of source operand remains unalterd

The MOV instruction causes amhugeuity at times. For example, look at the statements −

MOV  EBX, [MY_TABLE]  ; Effective Adgown of MY_TABLE in EBX
MOV  [EBX], 110	      ; MY_TABLE[0] = 110

It is not clear whether you want to move a simply simply byte equivalent or word equivalent of the numbecomer 110. In such cases, it is wise to use a type specifier.

Folloearng table shows a few of the common type specifiers −

Type Specifier Bytes adgowned
BYTE 1
WORD 2
DWORD 4
QWORD 8
TBYTE 10

Example

The folloearng program illustrates a few of the concepts discussed above. It stores a name 'Zara Ali' in the data section of the memory, then alters it’s value to another name 'Nuha Ali' programmatically and displays both the names.

section	.text
   global_start     ;must become declacrimson for linker (ld)
_start:             ;tell linker enattempt point
	
   ;writing the name 'Zara Ali'
   mov	edx,9       ;message duration
   mov	ecx, name   ;message to write
   mov	ebx,1       ;file descriptor (stdaway right now there)
   mov	eax,4       ;system call numbecomer (sys_write)
   int	0x80        ;call kernel
	
   mov	[name],  dword 'Nuha'    ; Changed the name to Nuha Ali
	
   ;writing the name 'Nuha Ali'
   mov	edx,8       ;message duration
   mov	ecx,name    ;message to write
   mov	ebx,1       ;file descriptor (stdaway right now there)
   mov	eax,4       ;system call numbecomer (sys_write)
   int	0x80        ;call kernel
	
   mov	eax,1       ;system call numbecomer (sys_exit)
   int	0x80        ;call kernel

section	.data
name db 'Zara Ali '

When the above code is compibrought and executed, it produces the folloearng result −

Zara Ali Nuha Ali

Assembly – Variables

NASM provides various degreat immediateives for reserving storage space for variables. The degreat bumembler immediateive is used for allocation of storage space. It can become used to reserve as well as preliminaryize one or more simply simply bytes.

Allocating Storage Space for Initialized Data

The syntax for storage allocation statement for preliminaryized data is −

[variable-name]    degreat-immediateive    preliminary-value   [,preliminary-value]...

Where, variable-name is the identifier for every storage space. The bumembler bumociates an awayset value for every variable name degreatd in the data segment.

There are five fundamental forms of the degreat immediateive −

Directive Purpose Storage Space
DB Degreat Byte allocates 1 simply simply byte
DW Degreat Word allocates 2 simply simply bytes
DD Degreat Doubleword allocates 4 simply simply bytes
DQ Degreat Quadword allocates 8 simply simply bytes
DT Degreat Ten Bytes allocates 10 simply simply bytes

Folloearng are a few examples of uperform degreat immediateives −

choice		DB	'y'
numbecomer		DW	12345
neg_numbecomer	DW	-12345
huge_numbecomer	DQ	123456789
real_numbecomer1	DD	1.234
real_numbecomer2	DQ	123.456

Plrerestve note thead wear −

  • Each simply simply byte of charget take actionioner is stocrimson as it’s ASCII value in hexadecimal.

  • Each decimal value is automatically converted to it’s 16-bit binary equivalent and stocrimson as a hexadecimal numbecomer.

  • Processor uses the small-endian simply simply byte ordering.

  • Negative numbecomers are converted to it’s 2's complement representation.

  • Short and sizey floating-point numbecomers are represented uperform 32 or 64 bit’s, respectively.

The folloearng program shows the use of degreat immediateive −

section .text
   global _start          ;must become declacrimson for linker (gcc)
	
_start:                   ;tell linker enattempt point
   mov	edx,1		  ;message duration
   mov	ecx,choice        ;message to write
   mov	ebx,1		  ;file descriptor (stdaway right now there)
   mov	eax,4		  ;system call numbecomer (sys_write)
   int	0x80		  ;call kernel

   mov	eax,1		  ;system call numbecomer (sys_exit)
   int	0x80		  ;call kernel

section .data
choice DB 'y'

When the above code is compibrought and executed, it produces the folloearng result −

y

Allocating Storage Space for Unpreliminaryized Data

The reserve immediateives are used for reserving space for unpreliminaryized data. The reserve immediateives conaspectr a performle operand thead wear specifies the numbecomer of devices of space to become reserved. Each degreat immediateive has a related reserve immediateive.

There are five fundamental forms of the reserve immediateive −

Directive Purpose
RESB Reserve a Byte
RESW Reserve a Word
RESD Reserve a Doubleword
RESQ Reserve a Quadword
REST Reserve a Ten Bytes

Multiple Definitions

You can have multiple data definition statements in a program. For example −

choice	  DB 	'Y' 		 ;ASCII of y = 79H
numbecomer1	  DW 	12345 	 ;12345D = 3039H
numbecomer2    DD  12345679  ;123456789D = 75BCD15H

The bumembler allocates contiguous memory for multiple variable definitions.

Multiple Initializations

The TIMES immediateive permit’s multiple preliminaryizations to the same value. For example, an array named marks of dimension 9 can become degreatd and preliminaryized to zero uperform the folloearng statement −

marks  TIMES  9  DW  0

The TIMES immediateive is helpful in defining arrays and tables. The folloearng program displays 9 asterisks on the screen −

section	.text
   global _start        ;must become declacrimson for linker (ld)
	
_start:                 ;tell linker enattempt point
   mov	edx,9		;message duration
   mov	ecx, stars	;message to write
   mov	ebx,1		;file descriptor (stdaway right now there)
   mov	eax,4		;system call numbecomer (sys_write)
   int	0x80		;call kernel

   mov	eax,1		;system call numbecomer (sys_exit)
   int	0x80		;call kernel

section	.data
stars   times 9 db '*'

When the above code is compibrought and executed, it produces the folloearng result −

*********

Assembly – Constants

There are many immediateives provided simply simply by NASM thead wear degreat constants. We have already used the EQU immediateive in previous chapters. We will particularly discuss 3 immediateives −

  • EQU
  • %bumign
  • %degreat

The EQU Directive

The EQU immediateive is used for defining constants. The syntax of the EQU immediateive is as follows −

CONSTANT_NAME EQU expression

For example,

TOTAL_STUDENTS equ 50

You can then use this particular constant value in your own code, like −

mov  ecx,  TOTAL_STUDENTS 
cmp  eax,  TOTAL_STUDENTS

The operand of an EQU statement can become an expression −

LENGTH equ 20
WIDTH  equ 10
AREA   equ duration * width

Above code segment would degreat AREA as 200.

Example

The folloearng example illustrates the use of the EQU immediateive −

SYS_EXIT  equ 1
SYS_WRITE equ 4
STDIN     equ 0
STDOUT    equ 1
section	 .text
   global _start    ;must become declacrimson for uperform gcc
	
_start:             ;tell linker enattempt point
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg1         
   mov edx, len1 
   int 0x80                
	
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg2         
   mov edx, len2 
   int 0x80 
	
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg3         
   mov edx, len3 
   int 0x80
   
   mov eax,SYS_EXIT    ;system call numbecomer (sys_exit)
   int 0x80            ;call kernel

section	 .data
msg1 db	'Hello, programmers!',0xA,0xD 	
len1 equ $ - msg1			

msg2 db 'Welcome to the world of,', 0xA,0xD 
len2 equ $ - msg2 

msg3 db 'Linux bumembly programming! '
len3 equ $- msg3

When the above code is compibrought and executed, it produces the folloearng result −

Hello, programmers!
Welcome to the world of,
Linux bumembly programming!

The %bumign Directive

The %bumign immediateive can become used to degreat numeric constants like the EQU immediateive. This immediateive permit’s crimsonefinition. For example, you may degreat the constant TOTAL as −

%bumign TOTAL 10

Later in the code, you can crimsonegreat it as −

%bumign  TOTAL  20

This immediateive is case-sensit downive.

The %degreat Directive

The %degreat immediateive permit’s defining both numeric and string constants. This immediateive is similar to the #degreat in C. For example, you may degreat the constant PTR as −

%degreat PTR [EBP+4]

The above code replaces PTR simply simply by [EBP+4].

This immediateive furthermore permit’s crimsonefinition and it is case-sensit downive.

Assembly – Arithmetic Instructions

The INC Instruction

The INC instruction is used for incrementing an operand simply simply by one. It works on a performle operand thead wear can become possibly in a register or in memory.

Syntax

The INC instruction has the folloearng syntax −

INC destination

The operand destination could become 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 simply simply by one. It works on a performle operand thead wear can become possibly in a register or in memory.

Syntax

The DEC instruction has the folloearng syntax −

DEC destination

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

Example

segment .data
   count dw  0
   value db  15
	
segment .text
   inc [count]
   dec [value]
	
   mov ebx, count
   inc word [ebx]
	
   mov esi, value
   dec simply simply byte [esi]

The ADD and SUB Instructions

The ADD and SUB instructions are used for performing basic addition/subtrget take actionionion of binary data in simply simply byte, word and doubleword dimension, i.e., for adding or subtrget take actionioning 8-bit, 16-bit or 32-bit operands, respectively.

Syntax

The ADD and SUB instructions have the folloearng syntax −

ADD/SUB	destination, source

The ADD/SUB instruction can conaspectr place becometween −

  • Register to register
  • Memory to register
  • Register to memory
  • Register to constant data
  • Memory to constant data

However, like other instructions, memory-to-memory operations are not achievable uperform ADD/SUB instructions. An ADD or SUB operation sets or clears the overflow and carry flags.

Example

The folloearng example will ask 2 digit’s from the user, store the digit’s 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 "Plrerestve enter a 2nd 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 become declacrimson for uperform gcc
	
_start:             ;tell linker enattempt 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 very first numbecomer to eax register and 2nd numbecomer to ebx
   ; and subtrget take actionioning ascii '0' to convert it into a decimal numbecomer
	
   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

When the above code is compibrought and executed, it produces the folloearng result −

Enter a digit:
3
Plrerestve enter a 2nd digit:
4
The sum is:
7

The program with hardcoded variables −

section	.text
   global _start    ;must become declacrimson for uperform gcc
	
_start:             ;tell linker enattempt 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 (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	ecx,sum
   mov	edx, 1
   mov	ebx,1	;file descriptor (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	eax,1	;system call numbecomer (sys_exit)
   int	0x80	;call kernel
	
section .data
   msg db "The sum is:", 0xA,0xD 
   len equ $ - msg   
   segment .bss
   sum resb 1

When the above code is compibrought and executed, it produces the folloearng result −

The sum is:
7

The MUL/IMUL Instruction

There are 2 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

The syntax for the MUL/IMUL instructions is as follows −

MUL/IMUL multiprestr

Multiplicand in both cases will become in an accumulator, depending upon the dimension of the multiplicand and the multiprestr and the generated item is furthermore stocrimson in 2 registers depending upon the dimension of the operands. Folloearng section excommons MUL instructions with 3 various cases −

SN Scenarios
1

When 2 simply simply bytes are multiprestd –

The multiplicand is within the AL register, and the multiprestr is a simply simply byte in the memory or in another register. The item is within AX. High-order 8 bit’s of the item is stocrimson in AH and the low-order 8 bit’s are stocrimson in AL.

Arithmetic1

2

When 2 one-word values are multiprestd –

The multiplicand need to become in the AX register, and the multiprestr is a word in memory or another register. For example, for an instruction like MUL DX, you must store the multiprestr in DX and the multiplicand in AX.

The resultant item is a doubleword, which will need 2 registers. The high-order (leftmany kind of) slotion gets stocrimson in DX and the lower-order (appropriatemany kind of) slotion gets stocrimson in AX.

Arithmetic2

3

When 2 doubleword values are multiprestd –

When 2 doubleword values are multiprestd, the multiplicand need to become in EAX and the multiprestr is a doubleword value stocrimson in memory or in another register. The item generated is stocrimson in the EDX:EAX registers, i.e., the high order 32 bit’s gets stocrimson in the EDX register and the low order 32-bit’s are stocrimson in the EAX register.

Arithmetic3

Example

MOV AL, 10
MOV DL, 25
MUL DL
...
MOV DL, 0FFH	; DL= -1
MOV AL, 0BEH	; AL = -66
IMUL DL

Example

The folloearng example multiprests 3 with 2, and displays the result −

section	.text
   global _start    ;must become declacrimson for uperform gcc
	
_start:             ;tell linker enattempt 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 (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	ecx,res
   mov	edx, 1
   mov	ebx,1	;file descriptor (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	eax,1	;system call numbecomer (sys_exit)
   int	0x80	;call kernel

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

When the above code is compibrought and executed, it produces the folloearng result −

The result is:
6

The DIV/IDIV Instructions

The division operation generates 2 elements – a quoconnectnt and a remainder. In case of multiplication, overflow does not occur becomecause double-duration registers are used to maintain the item. 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

The format for the DIV/IDIV instruction −

DIV/IDIV	divisor

The dividend is within an accumulator. Both the instructions can work with 8-bit, 16-bit or 32-bit operands. The operation affects all six status flags. Folloearng section excommons 3 cases of division with various operand dimension −

SN Scenarios
1

When the divisor is 1 simply simply byte –

The dividend is bumumed to become in the AX register (16 bit’s). After division, the quoconnectnt goes to the AL register and the remainder goes to the AH register.

Arithmetic4

2

When the divisor is 1 word –

The dividend is bumumed to become 32 bit’s sizey and in the DX:AX registers. The high-order 16 bit’s are in DX and the low-order 16 bit’s are in AX. After division, the 16-bit quoconnectnt goes to the AX register and the 16-bit remainder goes to the DX register.

Arithmetic5

3

When the divisor is doubleword –

The dividend is bumumed to become 64 bit’s sizey and in the EDX:EAX registers. The high-order 32 bit’s are in EDX and the low-order 32 bit’s are in EAX. After division, the 32-bit quoconnectnt goes to the EAX register and the 32-bit remainder goes to the EDX register.

Arithmetic6

Example

The folloearng example divides 8 with 2. The dividend 8 is stocrimson in the 16-bit AX register and the divisor 2 is stocrimson in the 8-bit BL register.

section	.text
   global _start    ;must become declacrimson for uperform gcc
	
_start:             ;tell linker enattempt 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 (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	ecx,res
   mov	edx, 1
   mov	ebx,1	;file descriptor (stdaway right now there)
   mov	eax,4	;system call numbecomer (sys_write)
   int	0x80	;call kernel
	
   mov	eax,1	;system call numbecomer (sys_exit)
   int	0x80	;call kernel
	
section .data
msg db "The result is:", 0xA,0xD 
len equ $- msg   
segment .bss
res resb 1

When the above code is compibrought and executed, it produces the folloearng result −

The result is:
4

Assembly – Logical Instructions

The processor instruction set provides the instructions AND, OR, XOR, TEST, and NOT Boolean logic, which tests, sets, and clears the bit’s according to the need of the program.

The format for these instructions −

SN Instruction Format
1 AND AND operand1, operand2
2 OR OR operand1, operand2
3 XOR XOR operand1, operand2
4 TEST TEST operand1, operand2
5 NOT NOT operand1

The very first operand in all the cases could become possibly in register or in memory. The 2nd operand could become possibly in register/memory or an immediate (constant) value. However, memory-to-memory operations are not achievable. These instructions compare or complement bit’s of the operands and set the CF, OF, PF, SF and ZF flags.

The AND Instruction

The AND instruction is used for supsloting logical expressions simply simply by performing bitwise AND operation. The bitwise AND operation returns 1, if the complementing bit’s from both the operands are 1, otherwise it returns 0. For example −

             Operand1: 	0101
             Operand2: 	0011
----------------------------
After AND -> Operand1:	0001

The AND operation can become used for clearing one or more bit’s. For example, say the BL register contains 0011 1010. If you need to clear the high-order bit’s to zero, you AND it with 0FH.

AND	BL,   0FH   ; This sets BL to 0000 1010

Let's conaspectr up another example. If you want to check whether a given numbecomer is odd or furthermore, a basic test would become to check the minimum significan not bit of the numbecomer. If this particular is 1, the numbecomer is odd, else the numbecomer is furthermore.

Assuming the numbecomer is within AL register, we can write −

AND	AL, 01H     ; ANDing with 0000 0001
JZ    EVEN_NUMBER

The folloearng program illustrates this particular −

Example

section .text
   global _start            ;must become declacrimson for uperform gcc
	
_start:                     ;tell linker enattempt point
   mov   ax,   8h           ;getting 8 in the ax 
   and   ax, 1              ;and ax with 1
   jz    evnn
   mov   eax, 4             ;system call numbecomer (sys_write)
   mov   ebx, 1             ;file descriptor (stdaway right now there)
   mov   ecx, odd_msg       ;message to write
   mov   edx, len2          ;duration of message
   int   0x80               ;call kernel
   jmp   away right now thereprog

evnn:   
  
   mov   ah,  09h
   mov   eax, 4             ;system call numbecomer (sys_write)
   mov   ebx, 1             ;file descriptor (stdaway right now there)
   mov   ecx, furthermore_msg      ;message to write
   mov   edx, len1          ;duration of message
   int   0x80               ;call kernel

away right now thereprog:

   mov   eax,1              ;system call numbecomer (sys_exit)
   int   0x80               ;call kernel

section   .data
furthermore_msg  db  'Even Numbecomer!' ;message shoearng furthermore numbecomer
len1  equ  $ - furthermore_msg 
   
odd_msg db  'Odd Numbecomer!'    ;message shoearng odd numbecomer
len2  equ  $ - odd_msg

When the above code is compibrought and executed, it produces the folloearng result −

Even Numbecomer!

Change the value in the ax register with an odd digit, like −

mov  ax, 9h                  ; getting 9 in the ax

The program would display:

Odd Numbecomer!

Similarly to clear the entire register you can AND it with 00H.

The OR Instruction

The OR instruction is used for supsloting logical expression simply simply by performing bitwise OR operation. The bitwise OR operator returns 1, if the complementing bit’s from possibly or both operands are one. It returns 0, if both the bit’s are zero.

For example,

             Operand1:     0101
             Operand2:     0011
----------------------------
After OR -> Operand1:    0111

The OR operation can become used for setting one or more bit’s. For example, permit us bumume the AL register contains 0011 1010, you need to set the four low-order bit’s, you can OR it with a value 0000 1111, i.e., FH.

OR BL, 0FH                   ; This sets BL to  0011 1111

Example

The folloearng example demonstrates the OR instruction. Let us store the value 5 and 3 in the AL and the BL registers, respectively, then the instruction,

OR AL, BL

need to store 7 in the AL register −

section .text
   global _start            ;must become declacrimson for uperform gcc
	
_start:                     ;tell linker enattempt point
   mov    al, 5             ;getting 5 in the al
   mov    bl, 3             ;getting 3 in the bl
   or     al, bl            ;or al and bl registers, result need to become 7
   add    al, simply simply byte '0'      ;converting decimal to ascii
	
   mov    [result],  al
   mov    eax, 4
   mov    ebx, 1
   mov    ecx, result
   mov    edx, 1 
   int    0x80
    
away right now thereprog:
   mov    eax,1             ;system call numbecomer (sys_exit)
   int    0x80              ;call kernel
	
section    .bss
result resb 1

When the above code is compibrought and executed, it produces the folloearng result −

7

The XOR Instruction

The XOR instruction implements the bitwise XOR operation. The XOR operation sets the resultant bit to 1, if and only if the bit’s from the operands are various. If the bit’s from the operands are same (both 0 or both 1), the resultant bit is cleacrimson to 0.

For example,

             Operand1:     0101
             Operand2:     0011
----------------------------
After XOR -> Operand1:    0110

XORing an operand with it’self alters the operand to 0. This is used to clear a register.

XOR     EAX, EAX

The TEST Instruction

The TEST instruction works same as the AND operation, but unlike AND instruction, it does not alter the very first operand. So, if we need to check whether a numbecomer in a register is furthermore or odd, we can furthermore do this particular uperform the TEST instruction withaway right now there changing the unique numbecomer.

TEST    AL, 01H
JZ      EVEN_NUMBER

The NOT Instruction

The NOT instruction implements the bitwise NOT operation. NOT operation reverses the bit’s in an operand. The operand could become possibly in a register or in the memory.

For example,

             Operand1:    0101 0011
After NOT -> Operand1:    1010 1100

Assembly – Conditions

Conditional execution in bumembly language is accomplished simply simply by many looping and branching instructions. These instructions can alter the flow of manage in a program. Conditional execution is observed in 2 scenarios −

SN Conditional Instructions
1

Unconditional jump

This is performed simply simply by the JMP instruction. Conditional execution regularly involves a transfer of manage to the adgown of an instruction thead wear does not follow the currently executing instruction. Transfer of manage may become forward, to execute a new set of instructions or backward, to re-execute the same steps.

2

Conditional jump

This is performed simply simply by a set of jump instructions j<condition> depending upon the condition. The conditional instructions transfer the manage simply simply by breacalifornia king the sequential flow and they do it simply simply by changing the awayset value in IP.

Let us discuss the CMP instruction becomefore discusperform the conditional instructions.

CMP Instruction

The CMP instruction compares 2 operands. It is generally used in conditional execution. This withinstruction fundamentalally subtrget take actionions one operand from the other for comparing whether the operands are equal or not. It does not disturb the destination or source operands. It is used asizey with the conditional jump instruction for decision macalifornia king.

Syntax

CMP destination, source

CMP compares 2 numeric data fields. The destination operand could become possibly in register or in memory. The source operand could become a constant (immediate) data, register or memory.

Example

CMP DX,	00  ; Compare the DX value with zero
JE  L7      ; If yes, then jump to labecomel L7
.
.
L7: ...  

CMP is regularly used for comparing whether a counter value has reveryed the numbecomer of times a loop needs to become run. Conaspectr the folloearng typical condition −

INC	EDX
CMP	EDX, 10	; Compares whether the counter has reveryed 10
JLE	LP1     ; If it is less than or equal to 10, then jump to LP1

Unconditional Jump

As mentioned earrestr, this particular is performed simply simply by the JMP instruction. Conditional execution regularly involves a transfer of manage to the adgown of an instruction thead wear does not follow the currently executing instruction. Transfer of manage may become forward, to execute a new set of instructions or backward, to re-execute the same steps.

Syntax

The JMP instruction provides a labecomel name where the flow of manage is transfercrimson immediately. The syntax of the JMP instruction is −

JMP	labecomel

Example

The folloearng code snippet illustrates the JMP instruction −

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 particular in turn doubles the CX value
JMP  L20       ; repeats the statements

Conditional Jump

If a few specified condition is satisfied in conditional jump, the manage flow is transfercrimson to a target instruction. There are a couple of conditional jump instructions depending upon the condition and data.

Folloearng are the conditional jump instructions used on signed data used for arithmetic operations −

Instruction Description Flags tested
JE/JZ Jump Equal or Jump Zero ZF
JNE/JNZ Jump not Equal or Jump Not Zero ZF
JG/JNLE Jump Greater or Jump Not Less/Equal OF, SF, ZF
JGE/JNL Jump Greater or Jump Not Less OF, SF
JL/JNGE Jump Less or Jump Not Greater/Equal OF, SF
JLE/JNG Jump Less/Equal or Jump Not Greater OF, SF, ZF

Folloearng are the conditional jump instructions used on unsigned data used for logical operations −

Instruction Description Flags tested
JE/JZ Jump Equal or Jump Zero ZF
JNE/JNZ Jump not Equal or Jump Not Zero ZF
JA/JNBE Jump Above or Jump Not Below/Equal CF, ZF
JAE/JNB Jump Above/Equal or Jump Not Below CF
JB/JNAE Jump Below or Jump Not Above/Equal CF
JBE/JNA Jump Below/Equal or Jump Not Above AF, CF

The folloearng conditional jump instructions have special uses and check the value of flags −

Instruction Description Flags tested
JXCZ Jump if CX is Zero none
JC Jump If Carry CF
JNC Jump If No Carry CF
JO Jump If Overflow OF
JNO Jump If No Overflow OF
JP/JPE Jump Parity or Jump Parity Even PF
JNP/JPO Jump No Parity or Jump Parity Odd PF
JS Jump Sign (negative value) SF
JNS Jump No Sign (posit downive value) SF

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 folloearng program displays the hugest of 3 variables. The variables are double-digit variables. The 3 variables num1, num2 and num3 have values 47, 72 and 31, respectively −

section	.text
   global _start         ;must become declacrimson for uperform gcc

_start:	                 ;tell linker enattempt 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   [hugest], ecx
   mov   ecx,msg
   mov   edx, len
   mov   ebx,1	;file descriptor (stdaway right now there)
   mov   eax,4	;system call numbecomer (sys_write)
   int   0x80	;call kernel
	
   mov   ecx,hugest
   mov   edx, 2
   mov   ebx,1	;file descriptor (stdaway right now there)
   mov   eax,4	;system call numbecomer (sys_write)
   int   0x80	;call kernel
    
   mov   eax, 1
   int   80h

section	.data
   
   msg db "The hugest digit is: ", 0xA,0xD 
   len equ $- msg 
   num1 dd '47'
   num2 dd '22'
   num3 dd '31'

segment .bss
   hugest resb 2  

When the above code is compibrought and executed, it produces the folloearng result −

The hugest digit is: 
47

Assembly – Loops

The JMP instruction can become used for implementing loops. For example, the folloearng code snippet can become 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 fundamental LOOP instruction has the folloearng syntax −

LOOP 	labecomel

Where, labecomel is the target labecomel thead wear identifies the target instruction as in the jump instructions. The LOOP instruction bumumes thead wear the ECX register contains the loop count. When the loop instruction is executed, the ECX register is decremented and the manage jumps to the target labecomel, until the ECX register value, i.e., the counter reveryes the value zero.

The above code snippet could become composed as −

mov ECX,10
l1:
<loop body>
loop l1

Example

The folloearng program prints the numbecomer 1 to 9 on the screen −

section	.text
   global _start        ;must become declacrimson for uperform gcc
	
_start:	                ;tell linker enattempt 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 numbecomer (sys_exit)
   int 0x80              ;call kernel
section	.bss
num resb 1

When the above code is compibrought and executed, it produces the folloearng result −

123456789:

Assembly – Numbecomers

Numerical data is generally represented in binary system. Arithmetic instructions operate on binary data. When numbecomers are displayed on screen or entecrimson from keytable, they are in ASCII form.

So far, we have converted this particular inplace data in ASCII form to binary for arithmetic calculations and converted the result back to binary. The folloearng code shows this particular −

section	.text
   global _start        ;must become declacrimson for uperform gcc
	
_start:	                ;tell linker enattempt 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 (stdaway right now there)
   mov	eax,4	         ;system call numbecomer (sys_write)
   int	0x80	         ;call kernel
	
   mov	ecx,sum
   mov	edx, 1
   mov	ebx,1	         ;file descriptor (stdaway right now there)
   mov	eax,4	         ;system call numbecomer (sys_write)
   int	0x80	         ;call kernel
	
   mov	eax,1	         ;system call numbecomer (sys_exit)
   int	0x80	         ;call kernel
	
section .data
msg db "The sum is:", 0xA,0xD 
len equ $ - msg   
segment .bss
sum resb 1

When the above code is compibrought and executed, it produces the folloearng result −

The sum is:
7

Such conversions, however, have an overmind, and bumembly language programming permit’s procesperform numbecomers in a more efficient way, in the binary form. Decimal numbecomers can become represented in 2 forms −

  • ASCII form
  • BCD or Binary Coded Decimal form

ASCII Representation

In ASCII representation, decimal numbecomers are stocrimson as string of ASCII charget take actionioners. For example, the decimal value 1234 is stocrimson 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 procesperform numbecomers in ASCII representation −

  • AAA − ASCII Adsimply After Addition

  • AAS − ASCII Adsimply After Subtrget take actionionion

  • AAM − ASCII Adsimply After Multiplication

  • AAD − ASCII Adsimply Before Division

These instructions do not conaspectr any kind of operands and bumume the requicrimson operand to become in the AL register.

The folloearng example uses the AAS instruction to demonstrate the concept −

section	.text
   global _start        ;must become declacrimson for uperform gcc
	
_start:	                ;tell linker enattempt point
   sub     ah, ah
   mov     al, '9'
   sub     al, '3'
   aas
   or      al, 30h
   mov     [res], ax
	
   mov	edx,len	        ;message duration
   mov	ecx,msg	        ;message to write
   mov	ebx,1	        ;file descriptor (stdaway right now there)
   mov	eax,4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	edx,1	        ;message duration
   mov	ecx,res	        ;message to write
   mov	ebx,1	        ;file descriptor (stdaway right now there)
   mov	eax,4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	eax,1	        ;system call numbecomer (sys_exit)
   int	0x80	        ;call kernel
	
section	.data
msg db 'The Result is:',0xa	
len equ $ - msg			
section .bss
res resb 1  

When the above code is compibrought and executed, it produces the folloearng result−

The Result is:
6

BCD Representation

There are 2 types of BCD representation −

  • Unpacked BCD representation
  • Packed BCD representation

In unpacked BCD representation, every simply simply byte stores the binary equivalent of a decimal digit. For example, the numbecomer 1234 is stocrimson as −

01	02	03	04H

There are 2 instructions for procesperform these numbecomers −

  • AAM – ASCII Adsimply After Multiplication
  • AAD – ASCII Adsimply Before Division

The four ASCII adsimply instructions, AAA, AAS, AAM, and AAD, can furthermore become used with unpacked BCD representation. In packed BCD representation, every digit is stocrimson uperform four bit’s. Two decimal digit’s are packed into a simply simply byte. For example, the numbecomer 1234 is stocrimson as −

12	34H

There are 2 instructions for procesperform these numbecomers −

  • DAA – Decimal Adsimply After Addition
  • DAS – decimal Adsimply After Subtrget take actionionion

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

Example

The folloearng program adds up 2 5-digit decimal numbecomers and displays the sum. It uses the above concepts −

section	.text
   global _start        ;must become declacrimson for uperform gcc

_start:	                ;tell linker enattempt point

   mov     esi, 4       ;pointing to the appropriatemany kind of digit
   mov     ecx, 5       ;num of digit's
   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 duration
   mov	ecx,msg	        ;message to write
   mov	ebx,1	        ;file descriptor (stdaway right now there)
   mov	eax,4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	edx,5	        ;message duration
   mov	ecx,sum	        ;message to write
   mov	ebx,1	        ;file descriptor (stdaway right now there)
   mov	eax,4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	eax,1	        ;system call numbecomer (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 '     '

When the above code is compibrought and executed, it produces the folloearng result −

The Sum is:
35801

Assembly – Strings

We have already used variable duration strings in our previous examples. The variable duration strings can have as many kind of charget take actionioners as requicrimson. Generally, we specify the duration of the string simply simply by possibly of the 2 ways −

  • Explicitly storing string duration
  • Uperform a sentinel charget take actionioner

We can store the string duration explicitly simply simply by uperform the $ location counter symbol thead wear represents the current value of the location counter. In the folloearng example −

msg  db  'Hello, world!',0xa ;our dear string
len  equ  $ - msg            ;duration of our dear string

$ points to the simply simply byte after the final charget take actionioner of the string variable msg. Therefore, $-msg gives the duration of the string. We can furthermore write

msg db 'Hello, world!',0xa ;our dear string
len equ 13                 ;duration of our dear string

Alternatively, you can store strings with a trailing sentinel charget take actionioner to delimit a string instead of storing the string duration explicitly. The sentinel charget take actionioner need to become a special charget take actionioner thead wear does not appear within a string.

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, however, the SI and the DI registers are used to point to the source and destination, respectively.

There are five fundamental instructions for procesperform strings. They are −

  • MOVS − This withinstruction moves 1 Byte, Word or Doubleword of data from memory location to another.

  • LODS − This withinstruction loads from memory. If the operand is of one simply simply 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.

  • STOS − This withinstruction stores data from register (AL, AX, or EAX) to memory.

  • CMPS − This withinstruction compares 2 data items in memory. Data could become of a simply simply byte dimension, word or doubleword.

  • SCAS − This withinstruction 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 simply simply byte, word, and doubleword version, and string instructions can become repeated simply simply by uperform a repetition prefix.

These instructions use the ES:DI and DS:SI pair of registers, where DI and SI registers contain valid awayset adgownes thead wear refers to simply simply bytes stocrimson in memory. SI is normally bumociated with DS (data segment) and DI is always bumociated 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 bumumed to become at DS:SI (or ESI) and the destination operand at ES:DI (or EDI) in memory.

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

The folloearng table provides various versions of string instructions and the bumumed space of the operands.

Basic Instruction Operands at Byte Operation Word Operation Double word Operation

MOVS

ES:DI, DS:EI MOVSB MOVSW MOVSD

LODS

AX, DS:SI LODSB LODSW LODSD

STOS

ES:DI, AX STOSB STOSW STOSD

CMPS

DS:SI, ES: DI CMPSB CMPSW CMPSD

SCAS

ES:DI, AX SCASB SCASW SCASD

Repetition Prefixes

The REP prefix, when set becomefore 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, decrrerestves CX simply simply by 1, and checks whether CX is zero. It repeats the instruction procesperform until CX is zero.

The Direction Flag (DF) figure outs the immediateion of the operation.

  • Use CLD (Clear Direction Flag, DF = 0) to make the operation left to appropriate.
  • Use STD (Set Direction Flag, DF = 1) to make the operation appropriate to left.

The REP prefix furthermore has the folloearng 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 ceases when the ZF indicates not equal/zero or when CX is zero.

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

Assembly – Arrays

We have already discussed thead wear the data definition immediateives to the bumembler are used for allocating storage for variables. The variable could furthermore become preliminaryized with a few specific value. The preliminaryized value could become specified in hexadecimal, decimal or binary form.

For example, we can degreat a word variable 'months' in possibly of the folloearng way −

MONTHS	DW	12
MONTHS	DW	0CH
MONTHS	DW	0110B

The data definition immediateives can furthermore become used for defining a one-dimensional array. Let us degreat a one-dimensional array of numbecomers.

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

The above definition declares an array of six words every preliminaryized with the numbecomers 34, 45, 56, 67, 75, 89. This allocates 2×6 = 12 simply simply bytes of consecutive memory space. The symbolic adgown of the very first numbecomer will become NUMBERS and thead wear of the 2nd numbecomer will become NUMBERS + 2 and so on.

Let us conaspectr up another example. You can degreat an array named inventory of dimension 8, and preliminaryize 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 become abbreviated as −

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

The TIMES immediateive can furthermore become used for multiple preliminaryizations to the same value. Uperform TIMES, the INVENTORY array can become degreatd as:

INVENTORY TIMES 8 DW 0

Example

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

section	.text
   global _start   ;must become declacrimson for linker (ld)
	
_start:	
 		
   mov  eax,3      ;numbecomer simply simply bytes to become summed 
   mov  ebx,0      ;EBX will store the sum
   mov  ecx, x     ;ECX will point to the current element to become 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 duration
   mov  ecx, sum   ;message to write
   mov  ebx, 1     ;file descriptor (stdaway right now there)
   mov  eax, 4     ;system call numbecomer (sys_write)
   int  0x80       ;call kernel
	
   mov  eax, 1     ;system call numbecomer (sys_exit)
   int  0x80       ;call kernel

section	.data
global x
x:    
   db  2
   db  4
   db  3

sum: 
   db  0

When the above code is compibrought and executed, it produces the folloearng result −

9

Assembly – Procedures

Procedures or subraway right now thereines are very imslotant in bumembly language, as the bumembly language programs tend to become huge in dimension. Procedures are identified simply simply by a name. Folloearng this particular name, the body of the procedure is describecomed which performs a well-degreatd job. End of the procedure is withindicated simply simply by a return statement.

Syntax

Folloearng is the syntax to degreat a procedure −

proc_name:
   procedure body
   ...
   ret

The procedure is calbrought from another function simply simply by uperform the CALL instruction. The CALL instruction need to have the name of the calbrought procedure as an argument as shown becomelow −

CALL proc_name

The calbrought procedure returns the manage to the calling procedure simply simply by uperform the RET instruction.

Example

Let us write an extremely basic procedure named sum thead wear adds the variables stocrimson in the ECX and EDX register and returns the sum in the EAX register −

section	.text
   global _start        ;must become declacrimson for uperform gcc
	
_start:	                ;tell linker enattempt point
   mov	ecx,'4'
   sub     ecx, '0'
	
   mov 	edx, '5'
   sub     edx, '0'
	
   call    sum          ;call sum procedure
   mov 	[res], eax
   mov	ecx, msg	
   mov	edx, len
   mov	ebx,1	        ;file descriptor (stdaway right now there)
   mov	eax,4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	ecx, res
   mov	edx, 1
   mov	ebx, 1	        ;file descriptor (stdaway right now there)
   mov	eax, 4	        ;system call numbecomer (sys_write)
   int	0x80	        ;call kernel
	
   mov	eax,1	        ;system call numbecomer (sys_exit)
   int	0x80	        ;call kernel
sum:
   mov     eax, ecx
   add     eax, edx
   add     eax, '0'
   ret
	
section .data
msg db "The sum is:", 0xA,0xD 
len equ $- msg   

segment .bss
res resb 1

When the above code is compibrought and executed, it produces the folloearng result −

The sum is:
9

Stacks Data Structure

A stack is an array-like data structure in the memory in which data can become stocrimson and removed from a location calbrought the 'top' of the stack. The data thead wear needs to become stocrimson is 'pushed' into the stack and data to become retrieved is 'popped' away right now there from the stack. Stack is a LIFO data structure, i.e., the data stocrimson very first is retrieved final.

Assembly language provides 2 instructions for stack operations: PUSH and POP. These instructions have syntaxes like −

PUSH    operand
POP     adgown/register

The memory space reserved in the stack segment is used for implementing stack. The registers SS and ESP (or SP) are used for implementing the stack. The top of the stack, which points to the final data item inserted into the stack is pointed to simply simply by the SS:ESP register, where the SS register points to the becomeginning of the stack segment and the SP (or ESP) gives the awayset into the stack segment.

The stack implementation has the folloearng charget take actionioneristics −

  • Only words or doublewords could become saved into the stack, not a simply simply byte.

  • The stack grows in the reverse immediateion, i.e., toward the lower memory adgown

  • The top of the stack points to the final item inserted in the stack; it points to the lower simply simply byte of the final word inserted.

As we discussed abaway right now there storing the values of the registers in the stack becomefore uperform all of them for a few use; it can become done in folloearng way −

; Save the AX and BX registers in the stack
PUSH    AX
PUSH    BX

; Use the registers for other purpose
MOV	AX, VALUE1
MOV 	BX, VALUE2
...
MOV 	VALUE1, AX
MOV	VALUE2, BX

; Restore the unique values
POP	AX
POP	BX

Example

The folloearng program displays the entire ASCII charget take actionioner set. The main program calls a procedure named display, which displays the ASCII charget take actionioner set.

section	.text
   global _start        ;must become declacrimson for uperform gcc
	
_start:	                ;tell linker enattempt point
   call    display
   mov	eax,1	        ;system call numbecomer (sys_exit)
   int	0x80	        ;call kernel
	
display:
   mov    ecx, 256
	
next:
   push    ecx
   mov     eax, 4
   mov     ebx, 1
   mov     ecx, achar
   mov     edx, 1
   int     80h
	
   pop     ecx	
   mov	dx, [achar]
   cmp	simply simply byte [achar], 0dh
   inc	simply simply byte [achar]
   loop    next
   ret
	
section .data
achar db '0'  

When the above code is compibrought and executed, it produces the folloearng result −

0123456789:;[email protected][]^_`abcdefghijklmnopqrstuvwxyz{|}
...
...

Assembly – Recursion

A recursive procedure is one which calls it’self. There are 2 kind of recursion: immediate and inimmediate. In immediate recursion, the procedure calls it’self and in inimmediate recursion, the very first procedure calls a 2nd procedure, which in turn calls the very first procedure.

Recursion could become observed in a couple of maall of thematical algorithms. For example, conaspectr the case of calculating the fget take actionionorial of a numbecomer. Fget take actionionorial of a numbecomer is given simply simply by the equation −

Fget take actionion (n) = n * fget take actionion (n-1) for n > 0

For example: fget take actionionorial of 5 is 1 x 2 x 3 x 4 x 5 = 5 x fget take actionionorial of 4 and this particular can become a great example of shoearng a recursive procedure. Every recursive algorithm must have an ending condition, i.e., the recursive calling of the program need to become ceaseped when a condition is fulfilbrought. In the case of fget take actionionorial algorithm, the end condition is reveryed when n is 0.

The folloearng program shows how fget take actionionorial n is implemented in bumembly language. To maintain the program basic, we will calculate fget take actionionorial 3.

section	.text
   global _start         ;must become declacrimson for uperform gcc
	
_start:                  ;tell linker enattempt point

   mov bx, 3             ;for calculating fget take actionionorial 3
   call  proc_fget take actionion
   add   ax, 30h
   mov  [fget take actionion], ax
    
   mov	  edx,len        ;message duration
   mov	  ecx,msg        ;message to write
   mov	  ebx,1          ;file descriptor (stdaway right now there)
   mov	  eax,4          ;system call numbecomer (sys_write)
   int	  0x80           ;call kernel

   mov   edx,1            ;message duration
   mov	  ecx,fget take actionion       ;message to write
   mov	  ebx,1          ;file descriptor (stdaway right now there)
   mov	  eax,4          ;system call numbecomer (sys_write)
   int	  0x80           ;call kernel
    
   mov	  eax,1          ;system call numbecomer (sys_exit)
   int	  0x80           ;call kernel
	
proc_fget take actionion:
   cmp   bl, 1
   jg    do_calculation
   mov   ax, 1
   ret
	
do_calculation:
   dec   bl
   call  proc_fget take actionion
   inc   bl
   mul   bl        ;ax = al * bl
   ret

section	.data
msg db 'Fget take actionionorial 3 is:',0xa	
len equ $ - msg			

section .bss
fget take actionion resb 1

When the above code is compibrought and executed, it produces the folloearng result −

Fget take actionionorial 3 is:
6

Assembly – Macros

Writing a macro is another way of ensuring modular programming in bumembly language.

  • A macro is a sequence of instructions, bumigned simply simply by a name and could become used any kind ofwhere in the program.

  • In NASM, macros are degreatd with %macro and %endmacro immediateives.

  • The macro becomegins with the %macro immediateive and ends with the %endmacro immediateive.

The Syntax for macro definition −

%macro macro_name  numbecomer_of_params
<macro body>
%endmacro

Where, numbecomer_of_params specifies the numbecomer parameters, macro_name specifies the name of the macro.

The macro is withinvoked simply simply by uperform the macro name asizey with the essential parameters. When you need to use a few sequence of instructions many kind of times in a program, you can place those instructions in a macro and use it instead of writing the instructions all the time.

For example, an extremely common need for programs is to write a string of charget take actionioners in the screen. For displaying a string of charget take actionioners, you need the folloearng sequence of instructions −

mov	edx,len	    ;message duration
mov	ecx,msg	    ;message to write
mov	ebx,1       ;file descriptor (stdaway right now there)
mov	eax,4       ;system call numbecomer (sys_write)
int	0x80        ;call kernel

In the above example of displaying a charget take actionioner string, the registers EAX, EBX, ECX and EDX have becomeen used simply simply by the INT 80H function call. So, every time you need to display on screen, you need to save these registers on the stack, invoke INT 80H and then restore the unique value of the registers from the stack. So, it could become helpful to write 2 macros for saving and restoring data.

We have observed thead wear, a few instructions like IMUL, IDIV, INT, etc., need a few of the information to become stocrimson in a few particular registers and furthermore return values in a few specific register(s). If the program was already uperform those registers for maintaining imslotant data, then the existing data from these registers need to become saved in the stack and restocrimson after the instruction is executed.

Example

Folloearng example shows defining and uperform macros −

; A macro with 2 parameters
; Implements the write system call
   %macro write_string 2 
      mov   eax, 4
      mov   ebx, 1
      mov   ecx, %1
      mov   edx, %2
      int   80h
   %endmacro
 
section	.text
   global _start            ;must become declacrimson for uperform gcc
	
_start:                     ;tell linker enattempt point
   write_string msg1, len1               
   write_string msg2, len2    
   write_string msg3, len3  
	
   mov eax,1                ;system call numbecomer (sys_exit)
   int 0x80                 ;call kernel

section	.data
msg1 db	'Hello, programmers!',0xA,0xD 	
len1 equ $ - msg1			

msg2 db 'Welcome to the world of,', 0xA,0xD 
len2 equ $- msg2 

msg3 db 'Linux bumembly programming! '
len3 equ $- msg3

When the above code is compibrought and executed, it produces the folloearng result −

Hello, programmers!
Welcome to the world of,
Linux bumembly programming!

Assembly – File Management

The system conaspectrs any kind of inplace or away right now thereplace data as stream of simply simply bytes. There are 3 standard file streams −

  • Standard inplace (stdin),
  • Standard away right now thereplace (stdaway right now there), and
  • Standard error (stderr).

File Descriptor

A file descriptor is a 16-bit integer bumigned to a file as a file id. When a new file is maked or an existing file is open uped, the file descriptor is used for accesperform the file.

File descriptor of the standard file streams – stdin, stdaway right now there and stderr are 0, 1 and 2, respectively.

File Pointer

A file pointer specifies the location for a subsequent read/write operation in the file in terms of simply simply bytes. Each file is conaspectcrimson as a sequence of simply simply bytes. Each open up file is bumociated with a file pointer thead wear specifies an awayset in simply simply bytes, relative to the becomeginning of the file. When a file is open uped, the file pointer is set to zero.

File Handling System Calls

The folloearng table briefly describecomes the system calls related to file handling −

%eax Name %ebx %ecx %edx
2 sys_fork struct pt_regs
3 sys_read unsigned int char * dimension_t
4 sys_write unsigned int const char * dimension_t
5 sys_open up const char * int int
6 sys_close up unsigned int
8 sys_creat const char * int
19 sys_lseek unsigned int away_t unsigned int

The steps requicrimson for uperform the system calls are same, as we discussed earrestr −

  • Put the system call numbecomer in the EAX register.
  • Store the arguments to the system call in the registers EBX, ECX, etc.
  • Call the relevant interrupt (80h).
  • The result is usually returned in the EAX register.

Creating and Opening a File

For creating and open uping a file, perform the folloearng tasks −

  • Put the system call sys_creat() numbecomer 8, in the EAX register.
  • Put the filename in the EBX register.
  • Put the file permissions in the ECX register.

The system call returns the file descriptor of the maked file in the EAX register, in case of error, the error code is within the EAX register.

Opening an Existing File

For open uping an existing file, perform the folloearng tasks −

  • Put the system call sys_open up() numbecomer 5, in the EAX register.
  • Put the filename in the EBX register.
  • Put the file access mode in the ECX register.
  • Put the file permissions in the EDX register.

The system call returns the file descriptor of the maked file in the EAX register, in case of error, the error code is within the EAX register.

Among the file access modes, many kind of commonly used are: read-only (0), write-only (1), and read-write (2).

Reading from a File

For reading from a file, perform the folloearng tasks −

  • Put the system call sys_read() numbecomer 3, in the EAX register.

  • Put the file descriptor in the EBX register.

  • Put the pointer to the inplace buffer in the ECX register.

  • Put the buffer dimension, i.e., the numbecomer of simply simply bytes to read, in the EDX register.

The system call returns the numbecomer of simply simply bytes read in the EAX register, in case of error, the error code is within the EAX register.

Writing to a File

For writing to a file, perform the folloearng tasks −

  • Put the system call sys_write() numbecomer 4, in the EAX register.

  • Put the file descriptor in the EBX register.

  • Put the pointer to the away right now thereplace buffer in the ECX register.

  • Put the buffer dimension, i.e., the numbecomer of simply simply bytes to write, in the EDX register.

The system call returns the get take actionionual numbecomer of simply simply bytes composed in the EAX register, in case of error, the error code is within the EAX register.

Cloperform a File

For cloperform a file, perform the folloearng tasks −

  • Put the system call sys_close up() numbecomer 6, in the EAX register.
  • Put the file descriptor in the EBX register.

The system call returns, in case of error, the error code in the EAX register.

Updating a File

For updating a file, perform the folloearng tasks −

  • Put the system call sys_lseek () numbecomer 19, in the EAX register.
  • Put the file descriptor in the EBX register.
  • Put the awayset value in the ECX register.
  • Put the reference posit downion for the awayset in the EDX register.

The reference posit downion could become:

  • Beginning of file – value 0
  • Current posit downion – value 1
  • End of file – value 2

The system call returns, in case of error, the error code in the EAX register.

Example

The folloearng program makes and open ups a file named myfile.txt, and writes a text 'Welcome to Tutorials Point' in this particular file. Next, the program reads from the file and stores the data into a buffer named info. Lastly, it displays the text as stocrimson in info.

section	.text
   global _start         ;must become declacrimson for uperform gcc
	
_start:                  ;tell linker enattempt point
   ;make the file
   mov  eax, 8
   mov  ebx, file_name
   mov  ecx, 0777        ;read, write and execute simply simply by all
   int  0x80             ;call kernel
	
   mov [fd_away right now there], eax
    
   ; write into the file
   mov	edx,len          ;numbecomer of simply simply bytes
   mov	ecx, msg         ;message to write
   mov	ebx, [fd_away right now there]    ;file descriptor 
   mov	eax,4            ;system call numbecomer (sys_write)
   int	0x80             ;call kernel
	
   ; close up the file
   mov eax, 6
   mov ebx, [fd_away right now there]
    
   ; write the message indicating end of file write
   mov eax, 4
   mov ebx, 1
   mov ecx, msg_done
   mov edx, len_done
   int  0x80
    
   ;open up the file for reading
   mov eax, 5
   mov ebx, file_name
   mov ecx, 0             ;for read only access
   mov edx, 0777          ;read, write and execute simply simply by all
   int  0x80
	
   mov  [fd_in], eax
    
   ;read from file
   mov eax, 3
   mov ebx, [fd_in]
   mov ecx, info
   mov edx, 26
   int 0x80
    
   ; close up the file
   mov eax, 6
   mov ebx, [fd_in]
    
   ; print the info 
   mov eax, 4
   mov ebx, 1
   mov ecx, info
   mov edx, 26
   int 0x80
       
   mov	eax,1             ;system call numbecomer (sys_exit)
   int	0x80              ;call kernel

section	.data
file_name db 'myfile.txt'
msg db 'Welcome to Tutorials Point'
len equ  $-msg

msg_done db 'Written to file', 0xa
len_done equ $-msg_done

section .bss
fd_away right now there resb 1
fd_in  resb 1
info resb  26

When the above code is compibrought and executed, it produces the folloearng result −

Written to file
Welcome to Tutorials Point

Assembly – Memory Management

The sys_brk() system call is provided simply simply by the kernel, to allocate memory withaway right now there the need of moving it later. This call allocates memory appropriate becomehind the application image in the memory. This system function permit’s you to set the highest available adgown in the data section.

This system call conaspectrs one parameter, which is the highest memory adgown needed to become set. This value is stocrimson in the EBX register.

In case of any kind of error, sys_brk() returns -1 or returns the negative error code it’self. The folloearng example demonstrates dynamic memory allocation.

Example

The folloearng program allocates 16kb of memory uperform the sys_brk() system call −

section	.text
   global _start         ;must become declacrimson for uperform gcc
	
_start:	                 ;tell linker enattempt point

   mov	eax, 45		 ;sys_brk
   xor	ebx, ebx
   int	80h

   add	eax, 16384	 ;numbecomer of simply simply bytes to become reserved
   mov	ebx, eax
   mov	eax, 45		 ;sys_brk
   int	80h
	
   cmp	eax, 0
   jl	exit	;exit, if error 
   mov	edi, eax	 ;EDI = highest available adgown
   sub	edi, 4		 ;pointing to the final DWORD  
   mov	ecx, 4096	 ;numbecomer of DWORDs allocated
   xor	eax, eax	 ;clear eax
   std			 ;backward
   rep	stosd            ;repete for entire allocated area
   cld			 ;place DF flag to normal state
	
   mov	eax, 4
   mov	ebx, 1
   mov	ecx, msg
   mov	edx, len
   int	80h		 ;print a message

exit:
   mov	eax, 1
   xor	ebx, ebx
   int	80h
	
section	.data
msg    	db	"Allocated 16 kb of memory!", 10
len     equ	$ - msg

When the above code is compibrought and executed, it produces the folloearng result −

Allocated 16 kb of memory!
SHARE
Previous articleJqueryUI Overview
Next articleSAP Lumira

NO COMMENTS

LEAVE A REPLY