Memory Segmentation

What Is Memory Segmentation?

Memory segmentation is a memory management technique where a program’s memory space is divided into discrete sections called segments, each representing a specific logical purpose like code, data, or stack.

In short, segmentation = logical division of memory into meaningful blocks.

This model was crucial in early CPU architectures (especially Intel x86) and remains foundational for understanding memory access, protection, and layout.

1. Why Segmentation?

Segmentation helps achieve:

Logical organization of memory
Efficient memory usage
Program isolation
Protection and privilege control
Support for multitasking and modularity

Instead of treating memory as one big linear array, segmentation provides a structured map.

2. Segmentation vs Paging

Feature	Segmentation	Paging
Unit of division	Logical units (code, data, stack)	Fixed-size blocks (pages)
Purpose	Logical organization	Physical memory management
Size	Variable	Fixed (typically 4KB)
Fragmentation	External fragmentation possible	Internal fragmentation possible
Translation	Segment selector + offset	Page table lookup

Modern OSes typically use paging, but segmentation still exists in legacy support and low-level operations.

3. Historical Context

Memory segmentation was introduced in early Intel x86 processors (e.g., 8086) due to 16-bit address limitations.

8086: 20-bit memory addressing using 16-bit segment registers + 16-bit offset
Enabled access to 1MB of memory despite 16-bit registers

This architecture laid the foundation for:

Real mode
Protected mode
Ring-based access control

4. Segment Types

Segment Type	Description
Code Segment (.text)	Contains executable instructions
Data Segment (.data)	Stores initialized global/static variables
BSS Segment (.bss)	Stores uninitialized variables
Stack Segment	Holds call stack: return addresses, local variables
Heap Segment	Dynamic memory allocated via `malloc`, `new`, etc.

These segments are not only logical in programming languages, but also mapped in hardware and OS memory models.

5. Segment Registers (x86 Architecture)

The Intel x86 architecture uses segment registers to manage memory access:

Register	Purpose
CS	Code Segment
DS	Data Segment
SS	Stack Segment
ES	Extra Segment
FS	General-purpose (OS use)
GS	General-purpose (OS use)

Example:

mov ax, DS      ; move data segment into AX
mov bx, [0x100] ; offset inside the DS segment

The physical address is computed as:

Physical Address = (Segment Register × 16) + Offset

6. Segmentation in Real Mode vs Protected Mode

Real Mode:

Used in early DOS systems
20-bit addressing
No memory protection
All programs share the same address space

Protected Mode:

Introduced in 80286+
Uses segment descriptors and descriptor tables
Enables:
- Access control (read/write/execute)
- Memory isolation
- Virtual memory support

7. Descriptor Tables and GDT/LDT

In protected mode, segment registers point to entries in descriptor tables:

GDT (Global Descriptor Table): Defines system-wide segments
LDT (Local Descriptor Table): Defines per-process segments

Each entry contains:

Base address
Segment limit
Access rights (privilege level, readability, executability)

Descriptor Format:

| Base Address (32-bit) |
| Segment Limit         |
| Access Rights         |

The CPU uses this info to validate and translate logical addresses to linear addresses.

8. Memory Address Translation Steps

Logical Address → Linear Address:

1. Logical Address = (Segment Selector : Offset)
2. Segment Selector → Descriptor Table Entry
3. Descriptor → Segment Base + Limit
4. Linear Address = Base + Offset

If paging is enabled:

5. Linear Address → Page Table Lookup → Physical Address

Thus, segmentation happens before paging in the memory access pipeline.

9. Segmentation and Memory Protection

Segmentation enforces process isolation by:

Assigning different segments to different tasks
Enabling hardware-level access control (privilege levels)
Supporting user/kernel mode distinction

If a program tries to access a memory segment outside its bounds or privilege, the CPU raises a segmentation fault.

10. Example Layout of a Process (Linux/ELF)

Modern OSes maintain the idea of segmentation in a virtual sense:

+----------------------------+
| Stack (dynamic, grows down)|
+----------------------------+
| Heap (dynamic, grows up)   |
+----------------------------+
| .bss (uninitialized data)  |
+----------------------------+
| .data (initialized data)   |
+----------------------------+
| .text (executable code)    |
+----------------------------+

Even though flat memory models are used today, this logical segmentation helps manage and protect memory efficiently.

11. Modern OS Perspective: Flat Segmentation Model

Modern operating systems (Linux, Windows, macOS) treat memory as a single flat address space, but still use segment registers in a default, fixed way:

All segments point to base = 0
Limit = max virtual memory
Segmentation acts as a legacy compatibility layer

The CPU segmentation hardware is still active, but configured to behave as if it doesn’t exist.

12. Relevance in Modern Systems

Role	Description
Security Mechanisms	Segment-level protection adds defense-in-depth
Compatibility	Supports legacy 16-bit applications
Low-Level OS Development	Used in bootloaders, kernels, interrupt handlers
Virtualization	Segment isolation can enhance VM sandboxing
Reverse Engineering / Debugging	Understanding segments is vital for analyzing binaries

13. Limitations of Segmentation

Complexity in address translation
Not scalable in large systems
Limited number of segment registers
Obsolete in 64-bit architectures (e.g., x86-64 ignores segmentation except FS/GS)

Thus, paging replaced segmentation in modern memory management.

Summary

Memory segmentation was a key architectural innovation that allowed programs to logically organize and protect memory. While largely replaced by paging in modern systems, it still provides foundational knowledge for: