How C Directly Controls Hardware: Registers, Memory, and Inline Assembly Explained

Hello, I am Xiao Feng. This is a series of articles about C language. In the previous article we learned why C is used to develop operating systems; this article looks at how C controls hardware.

C Language Design Philosophy

The design philosophy of C can be summed up as " Trust the programmer ". Unlike many modern languages, C imposes almost no restrictions and assumes the programmer knows what they are doing.

Therefore C is a language that demands a lot from programmers.

Decades later, despite many new languages, C remains the dominant language for operating system and device driver development because its features perfectly match system programming needs, especially its ability to directly control hardware.

CPU Registers and Memory

Before understanding how C directly controls hardware, we need to know two core hardware components: CPU registers and physical memory.

These two components form the foundation for instruction execution and data storage, and are the key interfaces for C's low‑level control.

CPU registers are small, fast storage units inside the processor; they are the direct objects of instruction execution.

Think of registers as the CPU's "workbench" where all computation occurs.

Registers are involved in loading instructions, performing operations, and accessing memory.

Registers serve to store temporary data, hold memory addresses, record CPU state, and control program flow.

Physical memory (RAM) is the main storage for program code, data, and runtime information. If registers are the workbench, physical memory is the "warehouse".

Physical memory stores executing program code, runtime data (variables, arrays, structs), and maintains program state (call stack, heap).

C's ability to control hardware is manifested in its control over registers and memory.

C Language's Tool for Controlling Registers: Inline Assembly

Inline assembly allows embedding assembly instructions directly in C code, enabling operations that C syntax cannot express.

Directly read/write specific CPU registers : access EAX, CR0, etc.

Execute privileged instructions : modify page tables, change processor modes, etc.

Extreme performance optimization : hand‑crafted assembly in performance‑critical paths.

GCC provides powerful inline‑assembly support; the basic syntax is:

<code>// Store EAX into result variable
asm volatile ("movl %%eax, %0" : "=r"(result) : );

// Load value into EAX
asm volatile ("movl %1, %%eax" : : "r"(value));

// System call
asm volatile ("int $0x80" : : "a"(syscall_num), "b"(arg1));
</code>

Inline assembly lets C bypass its abstractions and operate directly on physical registers (EAX, EBX, etc.) or specific memory addresses.

Operating system kernels use inline assembly for context switches, privilege level changes, page‑table manipulation, interrupt handling, and atomic operations.

However, inline assembly brings risks: it harms portability, increases code complexity, and can introduce hard‑to‑debug errors, so it is usually a last resort, wrapped in macros or functions for maintainability.

C Language's Tool for Controlling Memory: Pointers

Understanding pointers requires grasping the nature of variables.

When a variable like int a; is declared, the compiler allocates a block of memory (typically on the stack), associates it with the identifier, and records its type.

Variable names exist only in source code; after compilation they become concrete memory addresses.

A pointer is simply a variable whose value is the address of another variable, e.g., int *p; declares a pointer to an integer.

Since a pointer is a variable, it can be manipulated like any other, allowing C to directly operate on memory addresses and achieve precise hardware control.

In user space, pointers refer to virtual memory, while in kernel space they can access physical memory directly.

Through pointers, C bridges high‑level abstraction and low‑level hardware manipulation, but this power requires programmers to know exactly what they are doing.

Overall, using C for system programming demands clear awareness of the low‑level operations being performed.