Register in the processor is a type of computer memory. Which is used to quickly accept, store and transfer data and instructions being used immediately by the CPU. The registers used by the CPU are also called processor registers.
Assembly - Registers
Computer processors require instructions and processing data to work. Generally large and complex data is stored in hard drive to maintain it even after the computer is turned off. But processing data directly from the hard drive is very slow. That is why useful instructions and data to be processed further are loaded into the memory and accessed from there. Still, what data is such that it is being used again and again, such as instructions or data that has to be processed very quickly. That data is loaded into the register. Registers store data elements for processing without accessing memory. A limited number of registers are built into the processor chip.
To speed up the working of the processor, the processor includes some internal memory storage locations called registers. It is much faster than the rest of the memory. A processor register can contain an instruction, a storage address, or any data (such as a bit sequence or individual character).
We will use IA-32 architecture or 32bit and 16bit registers processor to understand the register.
Types of Registers
Registers are divided into different categories according to their work to help in the processing of data and CPU work in the computer. For example - general register, control register, segment register.
General registers
General registers - These registers are used for general processing of general data, arithmetic, point of logical next instruction, etc. Common registers can be 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 −
- Absolute 32-bit data registers from 0 to 31 index: EAX, EBX, ECX, EDX.
- The lower parts of the 32-bit registers are index 0 to 15. The four 16-bit data registers are AX, BX, CX, and DX.
- In the above four 16-bit registers -Lower eight 8-bit 0 through 7 indexes (AX BX CX and DX ). and higher from 8 to 15 index (AL , BL , CL ,DL) Data can be used as registers.
Some of these data registers have specific use in arithmetical operations.
- AX is the primary accumulatorit 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 registerIt 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)- There is a 16-bit IP register that stores the offset address of the next instruction to be executed. IP gives the full address of the current instruction in the code segment in association with the CS register (as CS:IP).
- Stack Pointer (SP) - The SP register provides an offset value within the program stack. The SP, in association with the SS register (SS:SP), represents the current position of the 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 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
Segment Registers
Segments are specific areas defined in a program for containing data, code and stack. There are three main segments −- Code Segment − It contains all the instructions to be executed. A 16-bit Code Segment register or CS register stores the starting address 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 address of the data segment.
- Stack Segment − It contains data and return addresses of procedures or subroutines. It is implemented as a 'stack' data structure. The Stack Segment register or SS register stores the starting address of the stack.
Apart from the DS, CS and SS registers, there are other extra segment registers - ES (extra segment), FS and GS, which provide additional segments for storing data.
In assembly programming, a program needs to access the memory locations. All memory locations within a segment are relative to the starting address of the segment. A segment begins in an address evenly divisible by 16 or hexadecimal 10. So, the rightmost hex digit in all such memory addresses is 0, which is not generally stored in the segment registers.
The segment registers stores the starting addresses of a segment. To get the exact location of data or instruction within a segment, an offset value (or displacement) is required. To reference any memory location in a segment, the processor combines the segment address in the segment register with the offset value of the location.
section .text
global _start ;must be declared for linker (gcc)
_start: ;tell linker entry point
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,7 ;message length
mov ecx,s2 ;message to write
mov ebx,1 ;file descriptor (stdout)
mov eax,4 ;system call number (sys_write)
int 0x80 ;call kernel
mov eax,1 ;system call number (sys_exit)
int 0x80 ;call kernel
section .data
msg db 'Displaying 7 hass',0xa ;a message
len equ $ - msg ;length of message
s2 times 7 db '#'
When the above code is compiled and executed, it produces the following result −
Displaying 7 hsss
#######
