Real mode, the default state after a system reset, offers simplicity but is limited to 1MB of addressable memory. Protected mode, introduced with the 80286 processor, allows for more advanced memory management and access to the full range of physical memory. However, switching to protected mode brings complexity. Unreal mode emerges as a hybrid solution, allowing access to extended memory within the simplicity of real mode.

What is Unreal Mode?

Unreal mode is a special operating state of the x86 CPU that allows a real mode program to access memory beyond the 1MB limit (up to 4GB) using 32-bit addressing. This is achieved by exploiting certain features of the CPU's segment registers and temporarily switching to protected mode to set them up.

• This is not a true processor mode, but rather a technique where a program switches back and forth between real mode and protected mode in order to access memory above 1MB while still using the BIOS.

Technical Explanation

Real Mode and Its Limitations

In real mode, memory addressing is done using segment pairs. Each segment register (CS, DS, ES, FS, GS, SS) contains a 16-bit value, which is shifted left by 4 bits (multiplied by 16) to form the base address of a segment. The offset, another 16-bit value, is added to this base address to form the final physical address. This addressing scheme limits the addressable memory to 1MB (0x00000 to 0xFFFFF).

Protected Mode and Its Advantages

Protected mode, on the other hand, uses a 32-bit address space, allowing access to a much larger range of memory. It employs segment descriptors in a Global Descriptor Table (GDT) to define the base address and limit of each segment, facilitating more complex memory management and protection features.

Transitioning to Unreal Mode

1. Switch to Protected Mode: Temporarily switch the CPU to protected mode to set up the segment registers.
2. Load Segment Registers: Load segment registers (DS, ES, FS, GS) with descriptors that have a base of 0 and a limit of 4GB.
3. Switch Back to Real Mode: Switch the CPU back to real mode without altering the segment registers. These registers retain their 32-bit limits, allowing access to the full 4GB address space while operating in real mode.

Detailed Example:

Here's an example of how to set up unreal mode in assembly language:

org 0x7C00

start:
    ; Load the GDT
    lgdt [gdt_descriptor]

    ; Enter protected mode
    cli                     ; Disable interrupts
    mov eax, cr0
    or eax, 1               ; Set PE (Protection Enable) bit
    mov cr0, eax

    ; Load 32-bit segment limits
    mov ax, 0x10            ; Selector for the data segment in the GDT
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov ss, ax

    ; Return to real mode
    mov eax, cr0
    and eax, 0xFFFFFFFE     ; Clear PE (Protection Enable) bit
    mov cr0, eax
    jmp far 0x08:real_mode  ; Far jump to flush prefetch queue

real_mode:
    ; Now in unreal mode
    ; DS, ES, FS, GS, SS still have 32-bit limits
    ; Access memory beyond 1MB here

    ; Example: Move a value to extended memory
    mov eax, 0x12345678
    mov [0x200000], eax     ; Write to physical address 2MB

    hlt                     ; Halt CPU

; Global Descriptor Table (GDT)
gdt:
    ; Null descriptor
    dw 0x0000, 0x0000, 0x0000, 0x0000
    ; Code segment descriptor (base=0, limit=4GB, code segment, read/execute)
    dw 0xFFFF, 0x0000, 0x9A00, 0x00CF
    ; Data segment descriptor (base=0, limit=4GB, data segment, read/write)
    dw 0xFFFF, 0x0000, 0x9200, 0x00CF

gdt_descriptor:
    dw gdt_end - gdt - 1    ; Limit of GDT
    dd gdt                  ; Base address of GDT

gdt_end:

times 510-($-$$) db 0       ; Fill to 510 bytes
dw 0xAA55                   ; Boot signature

Key Points of the Example

1. GDT Setup: The Global Descriptor Table (GDT) is defined with appropriate descriptors for code and data segments. These descriptors have a limit of 4GB.
2. Protected Mode Entry and Exit: The CPU is temporarily switched to protected mode to load the segment registers with the new GDT entries, then switched back to real mode.
3. Unreal Mode Operation: With segment registers retaining their 32-bit limits, memory beyond 1MB can be accessed in real mode.

Advantages and Disadvantages

Advantages

• Simplicity: Maintains the simple programming model of real mode.
• Extended Memory Access: Allows access to the full 4GB memory space.
• Legacy Support: Ideal for legacy systems and software that need more memory without the complexity of protected mode.

Disadvantages

• Limited Protection: Lacks the memory protection features of true protected mode.
• Complex Setup: Requires careful setup and management of the CPU state.
• Hardware Dependent: Behavior can vary slightly depending on the specific x86 CPU implementation.

Practical Applications

• DOS Extenders: Programs that extend DOS capabilities to access more memory.
• Bootloaders: Bootloaders that need to load large kernels or data structures into memory.
• Embedded Systems: Embedded systems that need simple memory access models with expanded memory.