The 32-bit instruction pointer
register and 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): indicates the overflow of a high-order bit (leftmost bit) of data after a signed arithmetic operation.
- Direction Flag (DF): 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): 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): 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): 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): 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): 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): 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): 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 of 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 provides 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 disable by 16 or hexadecimal 10. So all 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.
Example:
Look at the following simple program
to understand the use of registers in assembly programming. This program
displays 9 stars on the screen along with a simple message:
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,9 ;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 9 stars',0xa ;a message
len
equ $ - msg ;length of
message
s2
times 9 db '*'