BAHIR DAR UNIVERSITY

INSTITUTE OF TECHNOLOGY
Group assignment microprocessor and assembly language

Group name id

1.Emebet getachew..............................................

2.Firehiwot yibeltal ................................................

3.

4.

5.

Submitted to
 Mr.kaledawit Esmelealem

## Project Title: Understanding the Flags Register in x86 Assembly

## 1. Introduction

This project explores the functionality of the Flags Register in x86 assembly language. The Flags Register
is a crucial component of the CPU, reflecting the outcome of arithmetic and logical operations. We will
analyze how different flags within this register, such as Carry, Overflow, Sign, Zero, and Parity flags, are
affected by instructions like `ADD`, `SUB`, `MUL`, and `DIV `, cmp, inc, dec, and, or, neg, mov

## 2. Application Area

Understanding the Flags Register is fundamental for:

* Conditional Program Flow: Flags determine jumps and branches based on comparison results.

* Error Detection: Overflow and Carry flags help identify potential data truncation issues.

* Parity Checking: The Parity flag is used in data transmission to ensure data integrity.

## 3. Lookup Table / Diagram: Flags Register

| Flag | Bit Position | Description |

|---|---|---|

| CF (Carry Flag) | 0 | Set if an arithmetic operation results in a carry or borrow from the most significant
bit. |

| PF (Parity Flag) | 2 | Set if the result of an operation has an even number of 1 bits. |

| AF (Auxiliary Carry Flag) | 4 | Used for BCD arithmetic (not covered in this lab).|
| ZF (Zero Flag) | 6 | Set if the result of an operation is zero. |

| SF (Sign Flag) | 7 | Set if the result of an operation is negative. |

| TF (Trap Flag) | 8 | Used for debugging (not covered in this lab). |

| IF (Interrupt Flag) | 9 | Controls interrupt handling (not covered in this lab). |

| DF (Direction Flag) | 10 | Affects string operations (not covered in this lab). |

| OF (Overflow Flag) | 11 | Set if a signed arithmetic operation results in an out-of-range value. |

## 4. Flags and Instructions: A Deeper Dive

The Flags Register, in conjunction with various x86 instructions, plays a vital role in program control,
error detection, and data manipulation. Let's examine how different instruction groups affect the flags.

MOV AX, 0005

ADD AX, 3

; Carry Flag = 0 (no carry)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

* Explanation: The ADD instruction adds two operands. The Carry Flag (CF) is set if there is a carry-out
from the most significant bit. The Zero Flag (ZF) is set if the result is zero. The Sign Flag (SF) is set if the
result is negative.

• SUB (Subtraction):

* Code:

MOV AX, 2

SUB AX, 5

; Carry Flag = 1 (borrow occurred)

 ; Zero Flag = 0 (result not zero)

; Sign Flag = 1 (result negative)

* Explanation: The SUB instruction subtracts the second operand from the first. The Carry Flag (CF) is set
if a borrow is required during the subtraction. The Zero and Sign Flags work as described for ADD.

• INC (Increment):

* Code:

MOV AL, 0FFH

INC AL

; Carry Flag = 1 (overflow)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

* Explanation: The INC instruction increments the operand by 1. It affects the Carry Flag if the increment
results in an overflow.

• DEC (Decrement):

* Code:

MOV AL, 1

DEC AL

; Carry Flag = 0 (no borrow)

; Zero Flag = 1 (result is zero)

; Sign Flag = 0 (result positive)

* Explanation: The DEC instruction decrements the operand by 1. It affects the Carry Flag if a borrow is
required.
• MUL (Multiplication):

* Code:

MOV AX, 5

MUL AX ; Result in AX

; Carry Flag = 0 (no overflow)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

* Explanation: The MUL instruction multiplies two operands. For byte multiplication, the result is stored
in AL. For word multiplication, the result is stored in AX. The Carry Flag is set if an overflow occurs. The
Zero and Sign Flags are also affected.

• DIV (Division):

* Code:

MOV AX, 15

MOV BX, 5

DIV BX ; AX = 3 (Quotient), DX = 0 (Remainder)

; Carry Flag = 0 (no error)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

* Explanation: The DIV instruction divides the first operand (dividend) by the second (divisor). The result
is stored in AL for byte division and AX for word division. The remainder is stored in AH (byte) or DX
(word).

### 4.2 Logical Instructions

• AND (Bitwise AND):

* Code:

MOV AL, 01101011B

AND AL, 11000111B

; Carry Flag = 0 (not relevant)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

; Parity Flag = 1 (even number of 1s)

* Explanation: The AND instruction performs a bitwise AND operation between two operands. It affects
the Carry Flag, Zero Flag, and Parity Flag based on the result.

• OR (Bitwise OR):

* Code:

MOV AL, 01101011B

OR AL, 11000111B

; Carry Flag = 0 (not relevant)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

; Parity Flag = 0 (odd number of 1s)

* Explanation: The OR instruction performs a bitwise OR operation between two operands. It affects the
flags similarly to the AND instruction.

• XOR (Bitwise Exclusive OR):

 * Code:

MOV AL, 01101011B

XOR AL, 11000111B

; Carry Flag = 0 (not relevant)

; Zero Flag = 0 (result not zero)

; Sign Flag = 1 (result negative)

; Parity Flag = 0 (odd number of 1s)

* Explanation: The XOR instruction performs a bitwise exclusive OR operation. It affects the flags in a
similar manner to the AND and OR instructions.

• NOT (Bitwise NOT):

* Code:

MOV AL, 01101011B

NOT AL

; Carry Flag = 0 (not relevant)

; Zero Flag = 0 (result not zero)

; Sign Flag = 1 (result negative)

; Parity Flag = 1 (even number of 1s)

* Explanation: The NOT instruction inverts the bits of the operand. It affects the Parity Flag, Zero Flag,
and Sign Flag based on the result.

### 4.3 Data Transfer Instructions

• MOV (Move):

* Code:

MOV AX, 0005

; Carry Flag = Not affected

; Zero Flag = Not affected

; Sign Flag = Not affected

; Parity Flag = Not affected

* Explanation: The MOV instruction simply copies data from one location to another. It doesn't affect
any of the flags.

• PUSH/POP (Stack Operations):

* Code:

PUSH AX

; Carry Flag = Not affected

; Zero Flag = Not affected

; Sign Flag = Not affected

; Parity Flag = Not affected

* Explanation: PUSH and POP instructions interact with the stack, but they do not directly affect any
flags.

### 4.4 Control Flow Instructions

• CMP (Compare):
 * Code:

MOV AX, 5

CMP AX, 3

; Carry Flag = 0 (no borrow)

; Zero Flag = 0 (result not zero)

; Sign Flag = 0 (result positive)

* Explanation: The CMP instruction compares two operands but does not actually change their values. It
sets the flags based on the comparison result.

• JMP (Unconditional Jump):

* Code:

JMP LABEL

; Carry Flag = Not affected

; Zero Flag = Not affected

; Sign Flag = Not affected

; Parity Flag = Not affected

* Explanation: The JMP instruction jumps to a specified label without affecting any flags.

• JZ/JE (Jump if Zero):

* Code:

CMP AX, 5

JZ LABEL

; ...
* Explanation: The JZ (Jump if Zero) or JE (Jump if Equal) instruction jumps to a specific label if the Zero
Flag is set (ZF = 1).

• JNZ/JNE (Jump if Not Zero):

* Code:

CMP AX, 5

JNZ LABEL

; ...

* Explanation: The JNZ (Jump if Not Zero) or JNE (Jump if Not Equal) instruction jumps to a specific label
if the Zero Flag is cleared (ZF = 0).

• Conditional Jumps:

* The JG (Jump if Greater), JL (Jump if Less), JGE (Jump if Greater or Equal), JLE (Jump if Less or Equal),
JA (Jump if Above), JB (Jump if Below), JAE (Jump if Above or Equal), JBE (Jump if Below or Equal)
instructions are also used for conditional program flow. They use various combinations of flags to
determine the jump condition.

### 4.5 Debugging Example (EMU8086)

1. Load Your Code: Load the assembly code you wrote into EMU8086.

2. Set a Breakpoint: Click on the line number in the code editor where you want to pause execution.

3. Run the Program: Press F5 to start the program. It will pause at the breakpoint.

4. View Flags: The "Flags" window in EMU8086 will show the current state of the flags.

5. Step Through: Use the "Step Into" (F11) or "Step Over" (F10) commands to move to the next
instruction. Observe how the flags change as you step through the code.

### 4.6 Flag Combinations for Program Control

The following are examples of how flags can be combined to create complex conditional branching
scenarios:

• Checking for a Range:

CMP AX, 10 ; Check if AX is greater than or equal to 10

JGE IN_RANGE ; Jump if greater than or equal

; ... (code for out-of-range)

IN_RANGE:

; ... (code for in-range)

* Looping until a Condition is Met:

MOV CX, 10 ; Loop counter

LOOP_START:

; ... (code to process data)

DEC CX ; Decrement counter

JNZ LOOP_START ; Continue looping if CX is not zero

;…

## Exploring the Power of Flags in x86 Architecture

Flags, those tiny bits tucked away in the processor's status register, are often overlooked yet play a
crucial role in the functionality and efficiency of x86 processors. They provide vital information about the
results of operations, influencing the flow of execution and allowing for sophisticated program logic.
This report delves deeper into the world of flags, showcasing their versatility and demonstrating their
importance in various scenarios.

### 1. Flag Functionality and Scenarios

a) Memory Addressing

Flags can significantly enhance the efficiency of memory access operations. Consider the following
example in assembly language:

MOV AX, [BX + SI] ; Register Indirect Addressing with SI offset

JNZ NextInstruction ; Jump if Zero Flag is not set

Here, the MOV instruction uses register indirect addressing with an offset provided by the SI register. If
the instruction results in a zero value being moved into AX, the Zero Flag (ZF) will be set. The subsequent
JNZ instruction checks the ZF and jumps to NextInstruction if the flag is not set, meaning the moved
value was not zero. This demonstrates how flags can be combined with addressing modes to create
conditional logic and optimize data access.

b) Procedures and Subroutines

Flags are crucial for passing information between procedures and handling errors within subroutines.
Let's consider a simple subroutine that calculates the factorial of a number:

Factorial PROC

PUSH BP ; Preserve BP

MOV BP, SP ; Set BP to current stack frame

MOV AX, [BP+6] ; Get the input number from the stack
 CMP AX, 1 ; Compare with 1

JLE FactorialDone ; Jump if input is less than or equal to 1

DEC AX ; Decrement AX

PUSH AX ; Push decremented value onto stack

CALL Factorial ; Recursive call to calculate factorial of AX-1

POP BX ; Retrieve the result from the stack

MUL [BP+6] ; Multiply with original input

MOV AX, BX ; Store the result in AX

FactorialDone:

POP BP ; Restore BP

RET 6 ; Return from the procedure

Factorial ENDP

This code uses the Carry Flag (CF) to indicate potential overflows during multiplication. If CF is set, it
signals that the factorial calculation may have exceeded the limits of the register, requiring additional
error handling. Moreover, the Zero Flag (ZF) can be used within the FactorialDone label to indicate if the
input value was zero, allowing for specific handling.

c) Interrupts

Interrupts are events that disrupt the normal flow of program execution. Flags play a crucial role in
managing and handling these interrupts. The Interrupt Flag (IF) determines whether interrupts are
enabled or disabled. When an interrupt occurs, the processor saves the current program state, including
the values of various flags, and jumps to the appropriate interrupt handler routine. Upon returning from
the handler, the saved flags are restored, ensuring the program execution continues seamlessly.

d) Input/Output Operations
Flags are essential for efficient input/output operations. The Status Flag (SF) in the AH register is used by
the INT 21h function for input/output operations in MS-DOS. For instance, when reading data from a
port, the SF is set to indicate if the data is ready. This allows the program to check the flag and wait until
the data is available before processing it, ensuring smooth input operations.

### 2. History of x86 Flags

The x86 architecture has undergone significant evolution since its inception. The flag system has also
evolved, adding new flags and enhancing the functionality of existing ones. Early x86 processors had a
limited set of flags, primarily focused on basic arithmetic operations. As the architecture progressed,
new flags were introduced to handle more complex operations, such as floating-point calculations,
memory protection, and multitasking.

a) Early x86: The original 8086 processor had a basic flag set, including the Carry Flag (CF), Parity Flag
(PF), Auxiliary Carry Flag (AF), Zero Flag (ZF), Sign Flag (SF), and Overflow Flag (OF).

b) Later x86: As x86 evolved to the 80386 and beyond, the flag system expanded with additions like the
Direction Flag (DF), Interrupt Flag (IF), Trap Flag (TF), and the I/O Privilege Flag (IOPL). These additions
facilitated more complex tasks, including memory management, multitasking, and advanced
input/output operations.

c) Modern x86: Today, x86 processors utilize a comprehensive set of flags, including those associated
with floating-point operations (FP), SSE instructions, and other advanced functionalities.

### 3. Real-World Applications and Comparisons

Flags are essential in a wide range of applications:

• Embedded Systems: Flags are used extensively in embedded systems to manage hardware interrupts,
handle communication protocols, and control peripheral devices.
• Graphics Programming: Flags are crucial for rendering algorithms, managing graphics buffers, and
handling graphics pipeline operations.

• Operating Systems: Flags are critical for handling interrupts, managing memory, and implementing
security mechanisms.

Comparison to ARM Architecture:

ARM processors also use flags, but their implementation differs from x86. The ARM architecture uses a
Program Status Register (PSR) which contains multiple condition code flags, such as the Negative Flag
(N), Zero Flag (Z), Carry Flag (C), and Overflow Flag (V). These flags are used for conditional execution
and branch instructions. While the functionality of the flags is similar, their organization and usage are
different between the two architectures.

### 4. Enhanced Result Report:

a) Multiple Code Examples:

1) Using Flags for Error Handling in Division:

MOV AX, 10

MOV BX, 0

DIV BX ; Divide by zero will set the Zero Flag (ZF)

JNZ DivideDone

MOV AX, 0 ; Set AX to zero to indicate error

DivideDone:

; ...
2) Implementing a Conditional Loop using Flags:

MOV CX, 10

LoopStart:

; ...

DEC CX

JNZ LoopStart

b) Performance Analysis:

In performance-critical applications, using flags effectively can significantly improve efficiency. For
instance, using conditional jump instructions (like JNZ or JZ) based on flag values often outperforms
equivalent code implementations using multiple comparisons and branches.

c) Error Handling:

Flags are vital for implementing robust error handling mechanisms. By checking the status flags after
each operation, programs can identify potential errors like overflows, division by zero, or invalid
memory access. This allows the program to take appropriate corrective measures, preventing crashes
and ensuring data integrity.

## 4. Runnable Source Code and Analysis

.MODEL SMALL

.STACK 100H

.DATA
NUM1 DW 5

NUM2 DW 7

.CODE

MAIN PROC

; Carry Flag Example

MOV AL, 0FFH

ADD AL, 4 ; CF=1 (1 + 11111111 = (1)00000011)

; Overflow Flag Example

MOV BL, 4H

ADD BL, 7FH ; OF=1 (Result is 83H, exceeds the maximum for signed byte)

; Sign Flag Example

MOV AL, 2

SUB AL, 5 ; SF=1 (2 - 5 = -3)

; Zero Flag Example

MOV AX, 2

SUB AX, 2 ; ZF=1 (2 - 2 = 0)

; Parity Flag Example

MOV AL, 3
 ADD AL, 7 ; PF=1 (Result is 10D (1010B), even number of 1s)

; Multiplication Example

MOV AX, 5

CMP AX, 5 ; ZF=1, PF=1 (5 - 5 = 0)

; Division Example

MOV BH, 2H ; Divisor

MOV AL, 7H ; Dividend

DIV BH ; AL = 3 (Quotient), AH = 1 (Remainder)

; Conditional Branching Example

MOV AX, NUM1

CMP AX, NUM2

JG GREATER ; Jump if AX (NUM1) is greater than NUM2

MOV DX, NUM2 ; Else, move NUM2 to DX

JMP SKIP

GREATER:

MOV DX, NUM1 ; If greater, move NUM1 to DX

SKIP:

; ... rest of the code

MOV AH, 4CH ; Exit program

INT 21H

MAIN ENDP
END MAIN

; Cmp instruction

mov cl, [num1]

cmp cl, [num2]

; Inc instruction

mov dl, [num1]

inc dl

; Dec instruction

mov al, [num1]

dec al

; And instruction

mov bl, [num1]

and bl, [num2]

; Or instruction

mov cl, [num1]

or cl, [num2]

; Neg instruction

mov dl, [num1]

neg dl
 ; Mov instruction

mov al, [num1]

Code Breakdown:

1. Model and Stack:

- .MODEL SMALL: This line specifies the memory model for the program, using the small memory
model, limiting code and data segments to 64KB.

- .STACK 100H: This line reserves 100H (256 decimal) bytes of memory for the stack, where local
variables and function calls are managed.

2. Data Definitions:

- .DATA: This section defines variables, constants, and strings for the program.

- NUM1 DW 5: Declares a variable named NUM1 of type DW (Double Word) and assigns it the value 5.

- NUM2 DW 7: Declares a variable named NUM2 of type DW and assigns it the value 7.

3. Code Segment:

- .CODE: This section contains the program's executable instructions.

4. MAIN PROC:

- This is the starting point of the program.

- The code inside MAIN PROC performs the following operations:

* Carry Flag Example:

- MOV AL, 0FFH: Loads the value 0FFH (255 decimal) into the AL register.
 - ADD AL, 4: Adds the value 4 to AL. This operation sets the Carry Flag (CF) to 1 because the result
overflows the 8-bit register.

* Overflow Flag Example:

- MOV BL, 4H: Loads the value 4H (4 decimal) into the BL register.

- ADD BL, 7FH: Adds the value 7FH (127 decimal) to BL. This operation sets the Overflow Flag (OF) to 1
because the signed result (83H) exceeds the maximum value for a signed byte.

* Sign Flag Example:

- MOV AL, 2: Loads the value 2 into AL.

- SUB AL, 5: Subtracts 5 from AL. This operation sets the Sign Flag (SF) to 1 because the result (-3) is
negative.

* Zero Flag Example:

- MOV AX, 2: Loads the value 2 into AX.

- SUB AX, 2: Subtracts 2 from AX. This operation sets the Zero Flag (ZF) to 1 because the result (0) is
zero.

* Parity Flag Example:

- MOV AL, 3: Loads the value 3 into AL.

- ADD AL, 7: Adds 7 to AL. This operation sets the Parity Flag (PF) to 1 because the result (10D) has an
even number of 1s in its binary representation (1010B).

* Multiplication Example:

- MOV AX, 5: Loads 5 into AX.

- CMP AX, 5: Compares AX with 5. This sets ZF=1 and PF=1 because the result of the comparison is 0.
 * Division Example:

- MOV BH, 2H: Loads 2 into BH.

- MOV AL, 7H: Loads 7 into AL.

- DIV BH: Divides AL (dividend) by BH (divisor). The result is stored in AL (quotient = 3) and the
remainder in AH (remainder = 1).

* Conditional Branching Example:

- This section demonstrates conditional branching based on flag values.

- CMP AX, NUM2: Compares AX with NUM2.

- JG GREATER: Jumps to the label GREATER if the result of the comparison indicates AX is greater than
NUM2.

- MOV DX, NUM2: If the jump is not taken, NUM2 is moved to DX.

- JMP SKIP: Unconditional jump to SKIP.

- GREATER:: This label is jumped to if AX is greater than NUM2, and NUM1 is moved to DX.

- SKIP:: This label is reached unconditionally to continue the rest of the program.

* Program Exit:

- MOV AH, 4CH: Loads the exit program function code in nto

AH

INT 21H

: Calls the DOS interrupt to terminate the program.

5.

MAIN ENDP
:

- Marks the end of the

MAIN

procedure.

6.

END MAIN

- Indicates the end of the program.

In addition

+---------------------------------+

| Memory Address | Code/Data |

+---------------------------------+

| ... | ... |

| 0100 | MOV AL, FFH |

| 0103 | ADD AL, 04H |

| ... | ... |

| 0110 | MOV BL, 04H |

| 0113 | ADD BL, 7FH |

| ... | ... |

| 0120 | MOV AX, 0005 |

| 0123 | CMP AX, 0005 |

| ... | ... |

+---------------------------------+

| Registers | Values |

+---------------------------------+

| AX | 0005 |

| BX | ???? |

| CX | ???? |

| DX | ???? |

| ... | ... |

| AL | 00 |

| BL | ?? |

| AH | 00 |

| BH | 02 |

| ... | ... |

+---------------------------------+

| Flags | State |

+---------------------------------+

| CF | 1 |

| PF | 1 |

| AF | ? |

| ZF | 1 |

| SF | ? |

| ... | ... |

+---------------------------------+

| Output: |
+---------------------------------+

Explanation:

* Carry Flag: Illustrated by adding `0FFH` and 4, resulting in a carry.

* Overflow Flag: Demonstrated by adding `4H` and `7FH`, exceeding the maximum signed byte value.

* Sign, Zero, and Parity Flags: Explained with simple addition and subtraction operations.

* Multiplication and Division: Examples provided, but flag effects not directly relevant.

* Conditional Branching: A snippet showing how the `CMP` instruction sets flags, enabling the `JG`
(Jump if Greater) instruction to control program flow.

## 5. Conclus

Flags are a cornerstone of the x86 architecture, providing a mechanism for tracking operation results,
controlling program flow, and implementing sophisticated logic. Understanding their functionality is
crucial for optimizing code, writing efficient and robust programs, and developing sophisticated
applications. From simple arithmetic operations to complex interrupt handling and input/output
operations, flags play a crucial role in the efficient and reliable execution of programs on x86 processors

This project has provided a practical understanding of the Flags Register in x86 assembly. We examined
how various arithmetic and logical operations influence specific flags, highlighting their significance in
conditional execution, error checking, and data integrity. A deep understanding of the Flags Register is
essential for any programmer working with low-level programming or reverse engineering.