Build an OS: Cross Compiler, Bootloader & Kernel in C

Assembly language is a low-level programming language that translates human-readable code into binary instructions processors can execute. The core concept is Instruction Set Architecture (ISA), which defines processor instructions. Two main philosophies exist: CISC (x86/x86-64) uses complex instructions for maximum power, while RISC (ARM) uses simpler, more efficient instructions. Modern Apple devices use ARM for battery efficiency. Assembly uses different syntax flavors, with Intel syntax being more intuitive. The MOV instruction moves values between registers and memory. CPU registers are fast storage locations, with x86-64 registers being 64 bits and accessible at 8, 16, 32, or 64-bit sizes. General-purpose registers (RAX, RBX, RCX, RDX, RSI, RDI) handle data operations, while special-purpose registers (RIP, RSP, RBP) control execution flow and memory management. The RAX register conventionally stores function return values.

Intel processors use a complex x86 architecture with 16 general-purpose registers (RAX-R15) and specialized multimedia registers. The architecture includes an in-order execution section and an out-of-order execution section where sophisticated optimizations occur. The x86 assembly syntax places destinations on the left, with memory operands supporting complex addressing modes including base-plus-index-plus-displacement with scaling. Understanding this architecture helps developers write more efficient code by leveraging features like branch prediction, register renaming, and caching. The backward compatibility spanning over 30 years creates unique challenges and opportunities for optimization.

The Intel i386 architecture is the most common PC architecture, also known as x86 or i386. Introduced in 1985, it has evolved through generations like Xeon, Sandy Bridge, and Core. Assembly syntax comes in AT&T (source before destination, uses $ and %) and Intel (destination before source, no prefixes). The architecture has 32-bit general purpose registers (EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP) that are the fastest memory locations. EAX typically holds function return values, ECX serves as loop counters, and ESI/EDI handle string operations. EIP (Instruction Pointer) cannot be used as an operand and is only modified by call, jump, return, and interrupt instructions. The EFLAGS register contains status flags (CF, PF, ZF, SF) used for conditional execution. Memory management uses segmented model with CS, DS, SS, ES, FS, GS registers.

The programming model of x86 family microprocessors is a diagram of programmable registers. Advanced microprocessors are divided into 16-bit (8086, 8088, 80286) and 32-bit (386, 486, Pentium) versions. The 16-bit version uses 16-bit registers instead of 8-bit (like 8085). The 16-bit model contains three groups of registers: General Purpose Registers (AX, BX, CX, DX, SI, DI, BP, SP) for data processing and addressing; Segment Registers (CS, SS, DS, ES) for memory segmentation management; and Special Registers (IP, Flags) for program control and status. Each register serves specific functions: AX for calculations, SI/DI for string addressing, BP/SP for stack operations, CS/SS/DS/ES for memory segmentation, IP for instruction addressing, and Flags for status information.

x86 processors contain three main categories of registers: general-purpose registers (AX, BX, CX, DX and their 8-bit/32-bit/64-bit variants) for storing data during operations, flag registers for storing operation status bits (zero, carry, overflow, negative), and segment registers for managing memory segmentation. General-purpose registers can be accessed at different bit widths (8, 16, 32, 64 bits) through different naming conventions (e.g., AL/AX for 8/16 bits), while specialized registers like source/destination (SI/DI), pointer (BP, SP, IP), and floating-point (ST0-ST7) registers serve specific purposes. This hierarchical organization allows efficient data manipulation, memory addressing, and parallel processing operations.

The compilation process involves a tool chain consisting of four main stages: Preprocessor, Compiler, Assembler, and Linker. The preprocessor converts high-level language source code into .i files. The compiler takes these .i files and generates assembly language. The assembler then converts the assembly code into object files (.o). Finally, the linker combines multiple object files to produce the final executable binary file. This complete pipeline transforms human-readable source code into machine-executable binary instructions that hardware can understand.

The compiler converts expanded source code to assembly language, checking for syntax errors and generating equivalent instructions. The assembler translates assembly language (with mnemonic codes like MOV, ADD) into binary machine code, producing object files. The linker combines multiple object files and libraries into a single executable program, resolving references to library functions. Each stage progressively transforms code into a more machine-friendly format, with the linker creating the final executable file that can be run by the operating system.

The compilation process involves multiple tools: preprocessor, compiler, assembler, and linker. Even simple C programs require a linker because they often use external library functions like 'putchar' that the compiler cannot resolve. The linker combines object files with libraries to create executables. Understanding this tool chain is essential for program development.

A tool chain is a combination of multiple tools working together in a fixed order to convert source code into a final executable. The four tools in the compilation tool chain are: Preprocessor (first tool), Compiler (second tool), Assembler (third tool), and Linker (fourth tool). Each tool performs a specific transformation on the output of the previous tool.

A toolchain is a series of programming tools that work sequentially to transform source code into an executable program. The typical components include: (1) Make - manages the build process and calls the compiler; (2) GCC (GNU Compiler Collection) - the main compiler that calls several internal tools including CPP (C Preprocessor), compiler (CC1), assembler (gas), and linker (LD); (3) CPP processes code by expanding macros and including headers; (4) Compiler converts source code to assembly language; (5) Assembler translates assembly code to machine code; (6) Linker combines all object files and required libraries into a single executable program.

Modern operating systems separate user applications (userspace) from system applications (kernel space). This separation creates a barrier that prevents user applications from directly influencing kernel operations. Communication between user applications and the kernel must go through a special interface, typically implemented using interrupts. This design ensures system stability and security by preventing unauthorized access to critical system resources.

BIOS (Basic Input Output System) is firmware stored on a ROM chip that initializes hardware and runs the Power-On Self Test (POST) during computer startup, while CMOS (Complementary Metal Oxide Semiconductor) is non-volatile memory with a battery that stores BIOS configuration settings like boot order and hardware parameters; the boot process involves the BIOS performing hardware tests, reading CMOS settings, and loading the operating system from storage, with modern systems using UEFI (Unified Extensible Firmware Interface) which offers graphical interfaces and additional features compared to traditional text-based BIOS.

BIOS and UEFI are firmware programs that control hardware components before the operating system starts, with UEFI being the modern replacement for the older BIOS (Legacy BIOS). Both serve the same fundamental purpose of hardware control during boot, but UEFI offers several advantages: it supports mouse operation (unlike Legacy BIOS which only supports keyboard), handles hard disk capacities of 2TB or larger using GPT partition format (Legacy BIOS is limited to 2TB with MBR), enables faster boot times through 32-bit and 64-bit operation, and most importantly, allows network connectivity before OS startup for remote maintenance. Modern computers predominantly use UEFI, and while BIOS/UEFI updates may be necessary for bug fixes or new hardware support, they are not always required and carry potential risks.

BIOS (Basic Input Output System) is legacy firmware that initializes hardware and loads the Master Boot Record (MBR) from the first sector of a hard drive, which then finds an active partition and transfers control to its boot sector containing the boot manager; UEFI (Unified Extensible Firmware Interface) is a modern replacement that can boot from both MBR and GPT disks, supports network booting, and provides a more extensible API for developers, with boot variables specifying device paths, partition identifiers, and file paths to execute.

When a computer powers on, the boot process involves three sequential handovers: BIOS (Basic Input Output System) performs hardware checks and initialization, then the bootloader (like Windows Boot Manager or GRUB) loads the OS kernel, and finally the OS kernel takes control. BIOS is an older 16-bit technology with limitations including a 2.2TB storage limit, slow sequential device checking, weak security, and keyboard-only interface. UEFI (Unified Extensible Firmware Interface) addresses these limitations by supporting GPT partitioning (enabling storage up to 512TB), providing Secure Boot security, enabling parallel device checking for faster boot times, and offering a graphical user interface. Modern computers predominantly use UEFI, which became standard with Windows 8 and Intel 6th generation processors.