Arithmetic & Logic Operations: ALU, Flags, Binary Math, Logic Gates & Boolean Algebra

Core Concepts: ALU and Status Flags

The Arithmetic Logic Unit (ALU) is the heart of a microprocessor where all arithmetic and logic operations are performed. It takes inputs (operands) and produces results, while status flags (or condition codes) store the outcome of operations to influence program flow.

1. ALU Operations

The ALU performs two main types of operations:

• Arithmetic Operations: Addition, subtraction, multiplication, division, increment, decrement.
• Logic Operations: AND, OR, NOT, XOR, shifts (left/right), rotates.

How ALU Works

Status Flags (Condition Codes)

Flags are single-bit registers that store the result of an operation. Common flags:

---

2. Arithmetic Operations in Binary

A. Addition and Subtraction

Binary addition follows these rules:

0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0, carry = 1

Example: Adding 5 + 3 in 8-bit binary

  00000101 (5)
+ 00000011 (3)
-----------
  00000110 (6)

Subtraction is addition of two’s complement:

A - B = A + (-B)

Example: 5 - 3 in 8-bit

  00000101 (5)
+ 11111101 (-3, two’s complement)
-----------
  00000010 (2)

B. Multiplication and Division

Multiplication (Shift-and-Add)

Multiply by shifting and adding partial products:

Example: 5 × 3 = 15
Binary: 0101 × 0011

Division (Shift-and-Subtract)

Divide by repeatedly subtracting the divisor:

Example: 15 ÷ 3 = 5
Binary: 1111 ÷ 0011

---

3. Logic Operations and Boolean Algebra

Logic operations are performed using logic gates (AND, OR, NOT, XOR, NAND, NOR). They are fundamental to decision-making in processors.

A. Basic Logic Gates

B. Boolean Algebra Laws

Key laws used to simplify logic expressions:

1. Commutative: A + B = B + A, A • B = B • A
2. Associative: (A + B) + C = A + (B + C)
3. Distributive: A • (B + C) = (A • B) + (A • C)
4. De Morgan’s: ¬(A + B) = ¬A • ¬B, ¬(A • B) = ¬A + ¬B

Example: Simplify A • (A + B) Using absorption law: A • (A + B) = A

---

4. Real-World Applications

A. Banking (Interest Calculations)

Banks use ALU for compound interest calculations:

Formula: A = P (1 + r/n)^(nt)

• Example: If you deposit NPR 10,000 in a bank with 5% annual interest compounded annually for 2 years:

  A = 10000 (1 + 0.05)^2 = 10000 × 1.1025 = 11025
  

  The ALU performs repeated multiplication and addition to compute this.

B. E-Commerce (Order Processing)

When you place an order on Daraz or Hamrobazaar:

1. The server checks stock (logic operations: IF stock > 0 THEN proceed).
2. It calculates total price (arithmetic: price = quantity × unit_price).
3. It updates inventory (subtraction: stock = stock - quantity).

Example: Daraz Order Queue

C. Mobile Apps (Encryption)

WhatsApp uses XOR encryption for secure messaging:

• Plaintext P is XORed with a key K to get ciphertext C: C = P ⊕ K.
• The receiver XORs C with K again to recover P: P = C ⊕ K.

Example: Simple XOR Cipher

Plaintext: "A" (01000001)
Key:       "X" (01011000)
Ciphertext: "A ⊕ X" = 00011001 ("1")

---

5. Assembly Language Examples

A. Arithmetic Operations in x86 Assembly

; Add two numbers and store result
MOV AL, 5    ; Load 5 into AL
ADD AL, 3    ; AL = AL + 3 (Result = 8)
JZ  OVERFLOW ; Jump if result is zero (unlikely here)

; Subtract and check carry flag
MOV BL, 10
SUB BL, 15
JC  NEGATIVE ; Jump if carry (result < 0)

B. Logic Operations in ARM Assembly

; Check if two flags are both set (AND)
LDR R0, =FLAG1
LDR R1, =FLAG2
AND R2, R0, R1 ; R2 = FLAG1 AND FLAG2
CMP R2, #0
BEQ NOT_BOTH_SET

; Toggle a bit (XOR)
MOV R3, #1
EOR R4, R4, R3 ; Toggle least significant bit

---

6. Performance Considerations

Note: Modern CPUs use hardware multipliers/dividers for speed, but software emulation is slower.

---

7. Common Pitfalls and Errors

1. Signed vs. Unsigned Overflow:

   • ADD 127, 1 → Overflow (signed), but no carry (unsigned).
   • Fix: Use JO (jump on overflow) for signed checks.

2. Incorrect Flag Handling:

   • Forgetting to clear flags before operations (e.g., CLC to clear carry).

3. Boolean Algebra Mistakes:

   • Misapplying De Morgan’s laws (e.g., ¬(A + B) ≠ ¬A + ¬B).

4. Assembly Syntax Errors:

   • Using ADD A, B instead of ADD B, A (order matters in some architectures).

---

Exam Tip

What to Expect in TU/PU Exams

1. Theory Questions (30-40%):

   • Define ALU, status flags, and logic gates.
   • Explain signed vs. unsigned arithmetic with examples.
   • Compare RISC/CISC handling of arithmetic operations.

2. Worked Examples (30-40%):

   • Binary addition/subtraction with carry/overflow.
   • Boolean algebra simplification (e.g., simplify A + AB).
   • Assembly code tracing (e.g., predict flags after SUB).

3. Short Answer (20-30%):

   • "How does the ALU handle division?"
   • "What is the difference between carry and overflow flags?"
   • "Write an assembly snippet to check if two numbers are equal."

High-Scoring Strategies

• Draw diagrams for ALU operations, logic gates, and flag interactions.
• Show binary traces for arithmetic operations (e.g., 5 + (-3) in 8-bit).
• Relate to real-world apps (e.g., "How does WhatsApp use XOR?").
• Practice assembly on simulators like MARS (MIPS) or DOSBox (x86).

---

A step-by-step binary addition example with carry propagation. (Image: Phlsph7, CC0, via Wikimedia Commons)