Category: assembly Programming

Assembly – Recursion ”; Previous Next A recursive procedure is one that calls itself. There are two kind of recursion: direct and indirect. In direct recursion, the procedure calls itself and in indirect recursion, the first procedure calls a second procedure, which in turn calls the first procedure. Recursion could be observed in numerous mathematical algorithms. For example, consider the case of calculating the factorial of a number. Factorial of a number is given by the equation − Fact (n) = n * fact (n-1) for n > 0 For example: factorial of 5 is 1 x 2 x 3 x 4 x 5 = 5 x factorial of 4 and this can be a good example of showing a recursive procedure. Every recursive algorithm must have an ending condition, i.e., the recursive calling of the program should be stopped when a condition is fulfilled. In the case of factorial algorithm, the end condition is reached when n is 0. The following program shows how factorial n is implemented in assembly language. To keep the program simple, we will calculate factorial 3. Live Demo section .text global _start ;must be declared for using gcc _start: ;tell linker entry point mov bx, 3 ;for calculating factorial 3 call proc_fact add ax, 30h mov [fact], ax mov edx,len ;message length mov ecx,msg ;message to write mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov edx,1 ;message length mov ecx,fact ;message to write mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov eax,1 ;system call number (sys_exit) int 0x80 ;call kernel proc_fact: cmp bl, 1 jg do_calculation mov ax, 1 ret do_calculation: dec bl call proc_fact inc bl mul bl ;ax = al * bl ret section .data msg db ”Factorial 3 is:”,0xa len equ $ – msg section .bss fact resb 1 When the above code is compiled and executed, it produces the following result − Factorial 3 is: 6 Print Page Previous Next Advertisements ”;

Assembly – Useful Resources ”; Previous Next The following resources contain additional information on Assembly. Please use them to get more in-depth knowledge on this topic. Useful Video Courses Assembly Programming For All Platforms, Learn To Code 47 Lectures 2 hours Frahaan Hussain More Detail Arduino Car Parking Assistant 10 Lectures 42 mins Ashraf Said More Detail Java Courses in Tamil 188 Lectures 11.5 hours Programming Line More Detail VLSI, PLC, Microcontrollers, And Assembly Language 23 Lectures 12 hours Uplatz More Detail Make Blockbuster Movies -On your Own 30 Lectures 10 hours Tom Getty More Detail Solidworks from Beginner to Professional 34 Lectures 5 hours Shehzad Dalvi More Detail Print Page Previous Next Advertisements ”;

Assembly – Strings ”; Previous Next We have already used variable length strings in our previous examples. The variable length strings can have as many characters as required. Generally, we specify the length of the string by either of the two ways − Explicitly storing string length Using a sentinel character We can store the string length explicitly by using the $ location counter symbol that represents the current value of the location counter. In the following example − msg db ”Hello, world!”,0xa ;our dear string len equ $ – msg ;length of our dear string $ points to the byte after the last character of the string variable msg. Therefore, $-msg gives the length of the string. We can also write msg db ”Hello, world!”,0xa ;our dear string len equ 13 ;length of our dear string Alternatively, you can store strings with a trailing sentinel character to delimit a string instead of storing the string length explicitly. The sentinel character should be a special character that 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 basic instructions for processing strings. They are − MOVS − This instruction moves 1 Byte, Word or Doubleword of data from memory location to another. LODS − This instruction loads from memory. If the operand is of one byte, it is loaded into the AL register, if the operand is one word, it is loaded into the AX register and a doubleword is loaded into the EAX register. STOS − This instruction stores data from register (AL, AX, or EAX) to memory. CMPS − This instruction compares two data items in memory. Data could be of a byte size, word or doubleword. SCAS − This instruction compares the contents of a register (AL, AX or EAX) with the contents of an item in memory. Each of the above instruction has a byte, word, and doubleword version, and string instructions can be repeated by using a repetition prefix. These instructions use the ES:DI and DS:SI pair of registers, where DI and SI registers contain valid offset addresses that refers to bytes stored in memory. SI is normally associated with DS (data segment) and DI is always associated with ES (extra segment). The DS:SI (or ESI) and ES:DI (or EDI) registers point to the source and destination operands, respectively. The source operand is assumed to be at DS:SI (or ESI) and the destination operand at ES:DI (or EDI) in memory. For 16-bit addresses, the SI and DI registers are used, and for 32-bit addresses, the ESI and EDI registers are used. The following table provides various versions of string instructions and the assumed space of the operands. Basic Instruction Operands at Byte Operation Word Operation Double word Operation MOVS ES:DI, DS:SI 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 before a string instruction, for example – REP MOVSB, causes repetition of the instruction based on a counter placed at the CX register. REP executes the instruction, decreases CX by 1, and checks whether CX is zero. It repeats the instruction processing until CX is zero. The Direction Flag (DF) determines the direction of the operation. Use CLD (Clear Direction Flag, DF = 0) to make the operation left to right. Use STD (Set Direction Flag, DF = 1) to make the operation right to left. The REP prefix also has the following variations: REP: It is the unconditional repeat. It repeats the operation until CX is zero. REPE or REPZ: It is conditional repeat. It repeats the operation while the zero flag indicates equal/zero. It stops when the ZF indicates not equal/zero or when CX is zero. REPNE or REPNZ: It is also conditional repeat. It repeats the operation while the zero flag indicates not equal/zero. It stops when the ZF indicates equal/zero or when CX is decremented to zero. Print Page Previous Next Advertisements ”;

Assembly Programming Tutorial PDF Version Quick Guide Resources Job Search Discussion Assembly language is a low-level programming language for a computer or other programmable device specific to a particular computer architecture in contrast to most high-level programming languages, which are generally portable across multiple systems. Assembly language is converted into executable machine code by a utility program referred to as an assembler like NASM, MASM, etc. Audience This tutorial has been designed for those who want to learn the basics of assembly programming from scratch. This tutorial will give you enough understanding on assembly programming from where you can take yourself to higher levels of expertise. Prerequisites Before proceeding with this tutorial, you should have a basic understanding of Computer Programming terminologies. A basic understanding of any of the programming languages will help you in understanding the Assembly programming concepts and move fast on the learning track. Print Page Previous Next Advertisements ”;

Assembly – Variables ”; Previous Next NASM provides various define directives for reserving storage space for variables. The define assembler directive is used for allocation of storage space. It can be used to reserve as well as initialize one or more bytes. Allocating Storage Space for Initialized Data The syntax for storage allocation statement for initialized data is − [variable-name] define-directive initial-value [,initial-value]… Where, variable-name is the identifier for each storage space. The assembler associates an offset value for each variable name defined in the data segment. There are five basic forms of the define directive − Directive Purpose Storage Space DB Define Byte allocates 1 byte DW Define Word allocates 2 bytes DD Define Doubleword allocates 4 bytes DQ Define Quadword allocates 8 bytes DT Define Ten Bytes allocates 10 bytes Following are some examples of using define directives − choice DB ”y” number DW 12345 neg_number DW -12345 big_number DQ 123456789 real_number1 DD 1.234 real_number2 DQ 123.456 Please note that − Each byte of character is stored as its ASCII value in hexadecimal. Each decimal value is automatically converted to its 16-bit binary equivalent and stored as a hexadecimal number. Processor uses the little-endian byte ordering. Negative numbers are converted to its 2”s complement representation. Short and long floating-point numbers are represented using 32 or 64 bits, respectively. The following program shows the use of define directive − Live Demo section .text global _start ;must be declared for linker (gcc) _start: ;tell linker entry point mov edx,1 ;message length mov ecx,choice ;message to write mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov eax,1 ;system call number (sys_exit) int 0x80 ;call kernel section .data choice DB ”y” When the above code is compiled and executed, it produces the following result − y Allocating Storage Space for Uninitialized Data The reserve directives are used for reserving space for uninitialized data. The reserve directives take a single operand that specifies the number of units of space to be reserved. Each define directive has a related reserve directive. There are five basic forms of the reserve directive − 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 number1 DW 12345 ;12345D = 3039H number2 DD 12345679 ;123456789D = 75BCD15H The assembler allocates contiguous memory for multiple variable definitions. Multiple Initializations The TIMES directive allows multiple initializations to the same value. For example, an array named marks of size 9 can be defined and initialized to zero using the following statement − marks TIMES 9 DW 0 The TIMES directive is useful in defining arrays and tables. The following program displays 9 asterisks on the screen − Live Demo section .text global _start ;must be declared for linker (ld) _start: ;tell linker entry point mov edx,9 ;message length mov ecx, stars ;message to write mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov eax,1 ;system call number (sys_exit) int 0x80 ;call kernel section .data stars times 9 db ”*” When the above code is compiled and executed, it produces the following result − ********* Print Page Previous Next Advertisements ”;

Assembly – Macros ”; Previous Next Writing a macro is another way of ensuring modular programming in assembly language. A macro is a sequence of instructions, assigned by a name and could be used anywhere in the program. In NASM, macros are defined with %macro and %endmacro directives. The macro begins with the %macro directive and ends with the %endmacro directive. The Syntax for macro definition − %macro macro_name number_of_params <macro body> %endmacro Where, number_of_params specifies the number parameters, macro_name specifies the name of the macro. The macro is invoked by using the macro name along with the necessary parameters. When you need to use some sequence of instructions many times in a program, you can put those instructions in a macro and use it instead of writing the instructions all the time. For example, a very common need for programs is to write a string of characters in the screen. For displaying a string of characters, you need the following sequence of instructions − mov edx,len ;message length mov ecx,msg ;message to write mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel In the above example of displaying a character string, the registers EAX, EBX, ECX and EDX have been used by the INT 80H function call. So, each time you need to display on screen, you need to save these registers on the stack, invoke INT 80H and then restore the original value of the registers from the stack. So, it could be useful to write two macros for saving and restoring data. We have observed that, some instructions like IMUL, IDIV, INT, etc., need some of the information to be stored in some particular registers and even return values in some specific register(s). If the program was already using those registers for keeping important data, then the existing data from these registers should be saved in the stack and restored after the instruction is executed. Example Following example shows defining and using macros − Live Demo ; A macro with two 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 be declared for using gcc _start: ;tell linker entry point write_string msg1, len1 write_string msg2, len2 write_string msg3, len3 mov eax,1 ;system call number (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 assembly programming! ” len3 equ $- msg3 When the above code is compiled and executed, it produces the following result − Hello, programmers! Welcome to the world of, Linux assembly programming! Print Page Previous Next Advertisements ”;

Assembly – Memory Management ”; Previous Next The sys_brk() system call is provided by the kernel, to allocate memory without the need of moving it later. This call allocates memory right behind the application image in the memory. This system function allows you to set the highest available address in the data section. This system call takes one parameter, which is the highest memory address needed to be set. This value is stored in the EBX register. In case of any error, sys_brk() returns -1 or returns the negative error code itself. The following example demonstrates dynamic memory allocation. Example The following program allocates 16kb of memory using the sys_brk() system call − Live Demo section .text global _start ;must be declared for using gcc _start: ;tell linker entry point mov eax, 45 ;sys_brk xor ebx, ebx int 80h add eax, 16384 ;number of bytes to be 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 address sub edi, 4 ;pointing to the last DWORD mov ecx, 4096 ;number of DWORDs allocated xor eax, eax ;clear eax std ;backward rep stosd ;repete for entire allocated area cld ;put 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 compiled and executed, it produces the following result − Allocated 16 kb of memory! Print Page Previous Next Advertisements ”;

Assembly – Conditions ”; Previous Next Conditional execution in assembly language is accomplished by several looping and branching instructions. These instructions can change the flow of control in a program. Conditional execution is observed in two scenarios − Sr.No. Conditional Instructions 1 Unconditional jump This is performed by the JMP instruction. Conditional execution often involves a transfer of control to the address of an instruction that does not follow the currently executing instruction. Transfer of control may be forward, to execute a new set of instructions or backward, to re-execute the same steps. 2 Conditional jump This is performed by a set of jump instructions j<condition> depending upon the condition. The conditional instructions transfer the control by breaking the sequential flow and they do it by changing the offset value in IP. Let us discuss the CMP instruction before discussing the conditional instructions. CMP Instruction The CMP instruction compares two operands. It is generally used in conditional execution. This instruction basically subtracts 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 along with the conditional jump instruction for decision making. Syntax CMP destination, source CMP compares two numeric data fields. The destination operand could be either in register or in memory. The source operand could be a constant (immediate) data, register or memory. Example CMP DX, 00 ; Compare the DX value with zero JE L7 ; If yes, then jump to label L7 . . L7: … CMP is often used for comparing whether a counter value has reached the number of times a loop needs to be run. Consider the following typical condition − INC EDX CMP EDX, 10 ; Compares whether the counter has reached 10 JLE LP1 ; If it is less than or equal to 10, then jump to LP1 Unconditional Jump As mentioned earlier, this is performed by the JMP instruction. Conditional execution often involves a transfer of control to the address of an instruction that does not follow the currently executing instruction. Transfer of control may be forward, to execute a new set of instructions or backward, to re-execute the same steps. Syntax The JMP instruction provides a label name where the flow of control is transferred immediately. The syntax of the JMP instruction is − JMP label Example The following 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 in turn doubles the CX value JMP L20 ; repeats the statements Conditional Jump If some specified condition is satisfied in conditional jump, the control flow is transferred to a target instruction. There are numerous conditional jump instructions depending upon the condition and data. Following 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/Equal 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 Following 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 following 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 (positive 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 following program displays the largest of three variables. The variables are double-digit variables. The three variables num1, num2 and num3 have values 47, 22 and 31, respectively − Live Demo section .text global _start ;must be declared for using gcc _start: ;tell linker entry point mov ecx, [num1] cmp ecx, [num2] jg check_third_num mov ecx, [num2] check_third_num: cmp ecx, [num3] jg _exit mov ecx, [num3] _exit: mov [largest], ecx mov ecx,msg mov edx, len mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov ecx,largest mov edx, 2 mov ebx,1 ;file descriptor (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel mov eax, 1 int 80h section .data msg db “The largest digit is: “, 0xA,0xD len equ $- msg num1 dd ”47” num2 dd ”22” num3 dd ”31” segment .bss largest resb 2 When the above code is compiled and executed, it produces the following result − The largest digit is: 47 Print Page Previous Next Advertisements ”;

Assembly – Quick Guide ”; Previous Next Assembly – Introduction What is Assembly Language? Each personal computer has a microprocessor that manages the computer”s arithmetical, logical, and control activities. Each family of processors has its own set of instructions for handling various operations such as getting input from keyboard, displaying information on screen and performing various other jobs. These set of instructions are called ”machine language instructions”. A processor understands only machine language instructions, which are strings of 1”s and 0”s. However, machine language is too obscure and complex for using in software development. So, the low-level assembly language is designed for a specific family of processors that represents various instructions in symbolic code and a more understandable form. Advantages of Assembly Language Having an understanding of assembly 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 using assembly language are − It requires less memory and execution time; It allows hardware-specific complex jobs in an easier way; It is suitable for time-critical jobs; It is most suitable for writing interrupt service routines and other memory resident programs. Basic Features of PC Hardware The main internal hardware of a PC consists of processor, memory, and registers. Registers are processor components that hold data and address. To execute a program, the system copies it from the external device into the internal memory. The processor executes the program instructions. The fundamental unit of computer storage is a bit; it could be ON (1) or OFF (0) and a group of 8 related bits makes a byte on most of the modern computers. So, the parity bit is used to make the number of bits in a byte odd. If the parity is even, the system assumes that there had been a parity error (though rare), which might have been caused due to hardware fault or electrical disturbance. The processor supports the following data sizes − Word: a 2-byte data item Doubleword: a 4-byte (32 bit) data item Quadword: an 8-byte (64 bit) data item Paragraph: a 16-byte (128 bit) area Kilobyte: 1024 bytes Megabyte: 1,048,576 bytes Binary Number System Every number system uses positional notation, i.e., each position in which a digit is written has a different positional value. Each position is power of the base, which is 2 for binary number system, and these powers begin at 0 and increase by 1. The following table shows the positional values for an 8-bit binary number, where all bits are set ON. Bit value 1 1 1 1 1 1 1 1 Position value as a power of base 2 128 64 32 16 8 4 2 1 Bit number 7 6 5 4 3 2 1 0 The value of a binary number is based on the presence of 1 bits and their positional value. So, the value of a given binary number is − 1 + 2 + 4 + 8 +16 + 32 + 64 + 128 = 255 which is same as 28 – 1. Hexadecimal Number System Hexadecimal number system uses base 16. The digits in this system range from 0 to 15. By convention, the letters A through F is used to represent the hexadecimal digits corresponding to decimal values 10 through 15. Hexadecimal numbers in computing is used for abbreviating lengthy binary representations. Basically, hexadecimal number system represents a binary data by dividing each byte in half and expressing the value of each half-byte. The following table provides the decimal, binary, and hexadecimal equivalents − Decimal number 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 number to its hexadecimal equivalent, break it into groups of 4 consecutive groups each, starting from the right, and write those groups over the corresponding digits of the hexadecimal number. Example − Binary number 1000 1100 1101 0001 is equivalent to hexadecimal – 8CD1 To convert a hexadecimal number to binary, just write each hexadecimal digit into its 4-digit binary equivalent. Example − Hexadecimal number FAD8 is equivalent to binary – 1111 1010 1101 1000 Binary Arithmetic The following table illustrates four simple 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 position. Example Decimal Binary 60 00111100 +42 00101010 102 01100110 A negative binary value is expressed in two”s complement notation. According to this rule, to convert a binary number to its negative value is to reverse its bit values and add 1. Example Number 53 00110101 Reverse the bits 11001010 Add 1 00000001 Number -53 11001011 To subtract one value from another, convert the number being subtracted to two”s complement format and add the numbers. Example Subtract 42 from 53 Number 53 00110101 Number 42 00101010 Reverse the bits of 42 11010101 Add 1 00000001 Number -42 11010110 53 – 42 = 11 00001011 Overflow of the last 1 bit is lost. Addressing Data in Memory The process through which the processor controls the execution of instructions is referred as the fetch-decode-execute cycle or the execution cycle. It consists of three continuous steps − Fetching the instruction from memory Decoding or identifying the instruction Executing the instruction The processor may access one or more bytes of memory at a time. Let us consider a hexadecimal number 0725H. This number will require two bytes of memory. The high-order byte or most significant byte is 07 and the low-order byte is 25. The processor stores

Assembly – Registers ”; Previous Next Processor operations mostly involve processing data. This data can be stored in memory and accessed from thereon. However, reading data from and storing data into memory slows down the processor, as it involves complicated processes of sending the data request across the control bus and into the memory storage unit and getting the data through the same channel. To speed up the processor operations, the processor includes some internal memory storage locations, called registers. The registers store data elements for processing without having to access the memory. A limited number 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 three categories − General registers, Control registers, and Segment registers. The general registers are further divided into the following 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 be used in three ways − As complete 32-bit data registers: EAX, EBX, ECX, EDX. Lower halves of the 32-bit registers can be 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 be used as eight 8-bit data registers: AH, AL, BH, BL, CH, CL, DH, and DL. Some of these data registers have specific use in arithmetical operations. AX is the primary accumulator; it is used in input/output and most arithmetic instructions. For example, in multiplication operation, one operand is stored in EAX or AX or AL register according to the size of the operand. BX is known as the base register, as it could be used in indexed addressing. CX is known as the count register, as the ECX, CX registers store the loop count in iterative operations. DX is known as the data register. It is also used in input/output operations. It is also used with AX register along with DX for multiply and divide operations involving large values. Pointer Registers The pointer registers are 32-bit EIP, ESP, and EBP registers and corresponding 16-bit right portions IP, SP, and BP. There are three categories of pointer registers − Instruction Pointer (IP) − The 16-bit IP register stores the offset address of the next instruction to be executed. IP in association with the CS register (as CS:IP) gives the complete address of the current instruction in the code segment. Stack Pointer (SP) − The 16-bit SP register provides the offset value within the program stack. SP in association with the SS register (SS:SP) refers to be current position of data or address within the program stack. Base Pointer (BP) − The 16-bit BP register mainly helps in referencing the parameter variables passed to a subroutine. The address in SS register is combined with the offset in BP to get the location of the parameter. BP can also be combined with DI and SI as base register for special addressing. Index Registers The 32-bit index registers, ESI and EDI, and their 16-bit rightmost portions. SI and DI, are used for indexed addressing and sometimes used in addition and subtraction. There are two 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. Control Registers The 32-bit instruction pointer register and the 32-bit flags register combined are considered as the control registers. Many instructions involve comparisons and mathematical calculations and change the status of the flags and some other conditional instructions test the value of these status flags to take the control flow to other location. The common flag bits are: Overflow Flag (OF) − It indicates the overflow of a high-order bit (leftmost bit) of data after a signed arithmetic operation. Direction Flag (DF) − It determines left or right direction for moving or comparing string data. When the DF value is 0, the string operation takes left-to-right direction and when the value is set to 1, the string operation takes right-to-left direction. Interrupt Flag (IF) − It determines whether the external interrupts like keyboard entry, etc., are to be ignored or processed. It disables the external interrupt when the value is 0 and enables interrupts when set to 1. Trap Flag (TF) − It allows setting the operation of the processor in single-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 following the arithmetic operation. The sign is indicated by the high-order of leftmost bit. A positive 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 following an arithmetic operation; used for specialized arithmetic. The AF is set when a 1-byte arithmetic operation causes a carry from bit 3 into bit 4. Parity Flag (PF) − It indicates the total number of 1-bits in the result obtained from an arithmetic operation. An even number of 1-bits clears the parity flag to 0 and an odd number of 1-bits sets the parity flag to 1. Carry Flag (CF) − It contains the carry of 0 or 1 from a high-order bit (leftmost) after an arithmetic operation. It also stores the contents of last bit of a shift or rotate operation. The following table indicates the position of flag bits in the 16-bit Flags register: Flag: O D I T S Z A P C Bit no: 15 14 13