Memory Arrangement or Memory Segments
A segmented memory model splits the system memory into clusters or set of autonomous segments. Each independent segments referenced by pointers located in the segment registers. This is used to contain a specific type of data. One segment is used to hold instruction codes, another segment stores the data elements, and a third segment preserves the program stack. Though there are various memory segments such as
- Data segment :
This segment is represented by .data section and the .bss. The .data section is used to declare the memory section, where data elements are stored for the program. A section cannot be extended after the data elements are declared, and it remainders static all over the program.
- .bss section
This segment .bss section is also a static or not change memory section. This section comprises buffers for data to be declared later in the program. This buffer memory is zero-filled.
- Code segment
This is represented by .text section. This defines an area in memory that stores the instruction codes. This is also static or unchangeable or a fixed area.
- Stack
This segment that is stack contains data values passed to functions and procedures within the program. In order to speed up the processor operations, the processor includes some internal memory storage locations, called registers. Registers store data elements for processing without taking to access the memory. A partial 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, for example
- General registers,
- Control registers,
- Segment registers.
The general registers are further divided into the following categorise:
- Data registers,
- Pointer registers, and
- Index registers.
- Data Registers
There are four 32-bit data registers which are used for arithmetic, logical, and other operations. These 32-bit registers can be used in three ways, such as complete 32-bit data registers: EAX, EBX, ECX, EDX. Here, 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.
Data Registers
Some of these data registers have specific use in arithmetical operations.
AX is the primary accumulator where this is used in input/output and most arithmetic instructions. For instance , 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. This register 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 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.
Pointer Registers
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.
Index Registers
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): This flag is indicating the overflow of a high-order bit (leftmost bit) of data after a signed arithmetic operation.
Direction Flag (DF): This flag is determining 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): This flag is governs 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) ): This flag is 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) ): This flag is 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) ): This flag is 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): This flag is containing 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): This flag is indicating 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): This flag is containing 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.
Segment Registers
Segments are specific areas defined in a program for containing data, code and stack. There are three main segments:
- Code Segment: This flag is containing 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: This flag is 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: This flag is containing 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. These are combines the segment address in the segment register with the offset value of the location. Look at the following simple program to understand the use of registers.
Example
The use of registers in assembly programming. This program displays 7 stars on the screen with a message:
section .text
global _start ; This is must be declared for linker (gcc)
_start: ; This tell linker entry point
mov edx,len ; This is a message length
mov ecx,msg ; This is a message to write
mov ebx,1 ; This is a file descriptor (stdout)
mov eax,4 ; This is system call number (sys_write)
int 0x80 ; This is call kernel
mov edx,7 ; This is message length
mov ecx,s2 ; This is message to write
mov ebx,1 ; This is a file descriptor (stdout)
mov eax,4 ; This is system call number (sys_write)
int 0x80 ; This is call kernel
mov eax,1 ; This is system call number (sys_exit)
int 0x80 ; This is call kernel
section .data
msg db 'Displaying 7 stars',0xa ;a message
len equ $ - msg ;length of message
s2 times 7 db '*'
OUTPUT
Displaying 7 stars
*******