Hello everyone, I am Xiao Feng Ge, and today we will explore how the C language controls hardware.
The Design Philosophy of C Language
The design philosophy of C can be summarized as “trust the programmer“.
Unlike many modern programming languages, C imposes very few restrictions on the behavior of the programmer,it assumes that the programmer knows what they are doing.
Therefore, C is actually a language that demands a lot from programmers.
Decades have passed, and despite the emergence of many new programming languages, C remains the dominant language for operating system and device driver development. This is not a coincidence, but rather a perfect match between the characteristics of C and the needs of system programming, one of the key factors being C’s ability to achieve direct control over hardware.
How is this achieved?
CPU Registers and Memory
Before understanding how C directly controls hardware, we need to first understand two core components of computer hardware: CPU registers and physical memory.
These two components form the basis for executing instructions and storing data in a computer, and they are the key interfaces through which C can achieve low-level control.
CPU registers are high-speed, very small capacity storage units within the processor,they are the direct objects of operation when the CPU executes instructions.
One can think of registers as the CPU’s “workbench”, where all calculations and data processing must take place.
Whether loading instructions, performing calculations, or accessing memory, the involvement of registers is indispensable.
The main functions of registers include:
- Storing temporary data during instruction execution
- Saving memory addresses for memory access
- Recording the CPU’s working state (e.g., whether the result of a calculation is zero, whether a carry has occurred, etc.)
- Controlling the program execution flow (e.g., the address of the next instruction)
Next, let’s look at physical memory.
Physical memory, usually referring to main memory (RAM, Random Access Memory), is the primary storage device used by the computer to store program code, data, and runtime information. If we compare registers to the CPU’s “workbench”, then physical memory is the computer’s “large warehouse”, storing all the data needed for program execution.
The main functions of physical memory include:
- Storing the currently executing program code
- Saving data during program execution (e.g., variables, arrays, structures, etc.)
- Maintaining the program’s running state (e.g., function call stack, heap memory, etc.)
When we say that C can directly control hardware, it is more reflected in the control over registers and memory.
The Tool for C Language to Control Registers: Inline Assembly
Inline assembly allows the direct embedding of assembly instructions within C code, enabling low-level operations that cannot be expressed in C syntax:
-
Directly read and write specific CPU registers: Accessing specific registers like EAX, CR0, etc.
-
Execute privileged instructions: Operations that require special permissions, such as modifying page tables or changing processor modes.
-
Optimize for extreme performance: Using hand-optimized assembly code in performance-critical paths, etc.
The GCC compiler provides powerful inline assembly support, with the basic syntax as follows:
// Store the value of EAX register into result variable
asm volatile ("movl %%eax, %0" : "=r"(result) : );
// Load the value of variable into EAX register
asm volatile ("movl %1, %%eax" : : "r"(value));
// Perform a system call
asm volatile ("int $0x80" : : "a"(syscall_num), "b"(arg1));
Inline assembly is the most direct manifestation of C’s ability to penetrate its own abstraction and reach the hardware.
<span>asm</span> instructions can directly manipulatephysical registers (EAX, EBX, etc.) or specific memory addresses, bypassing C’s variable abstraction and the compiler’s register allocation mechanism.
The operating system kernel extensively uses inline assembly to implement:
- Context switching (saving and restoring register states)
- Switching processor privilege levels
- Page table operations
- Interrupt handling
- Atomic operations
Although inline assembly is powerful, it also brings risks and challenges:
- Breaking portability
- Increasing code complexity
- Potentially introducing hard-to-debug errors
Therefore, inline assembly is often regarded as a “last resort”, used only when absolutely necessary, and is typically encapsulated in macros or functions to improve maintainability.
The Tool for C Language to Control Memory: Pointers
Before understanding pointers in C, we must grasp the essence of variables.
When we declare a variable in C (e.g.,<span>int a; char c;</span>), what are we actually doing?
Essentially, we are requesting a block of memory from the compiler and giving it a name and type. The compiler allocates an appropriate amount of memory based on the variable’s type and records the starting address of this memory.
For example, when we declare<span>int a;</span>, the compiler will:
- Allocate 4 bytes (on most modern systems) in the appropriate memory area (usually the stack)
- Associate this memory with the identifier
<span>a</span> - Record that this memory should be interpreted as an integer type
Variable names are programmer-friendly identifiers that exist only in the source code and compilation phase. Once the program is compiled into machine code, variable names are replaced with specific memory addresses. When the CPU executes instructions, it is unaware of the existence of variable names; it only knows to operate on data at specific memory addresses.
Essentially, a pointer is also a variable, but its value is the memory address of another variable; in other words, a pointer “points to” a location in memory.
For example,<span>int *p;</span> declares a pointer to an integer, indicating to the compiler that<span>p</span>‘s value is a memory address, and the data stored at that address should be interpreted as an integer.
Since pointers are also variables, they can be subjected to regular operations like addition and subtraction, allowing C to directly manipulate memory addresses and achieve precise control over hardware.
It is important to note that while pointers can be used in user mode, they operate on virtual memory, which is still not true physical memory; however, in kernel mode, the operating system can directly manipulate physical memory.
Through pointers, C establishes a bridge between high-level language abstractions and low-level hardware operations.
The low-level control capabilities of C make it an ideal tool for addressing these challenges, although this also means that programmers must take on more responsibility to ensure the correctness and safety of their code.
In summary, when you use C for system programming,you need to be very clear about what you are doing.
Previous Historical Articles
01. Huawei + DeepSeek is here02. Breaking! A 1:1 replica of the Win11 system has been created and open-sourced!03. Complete deployment tutorial for DeepSeek-R1 671B04. It’s completely crazy! VM Workstation Pro is free!05. How to easily create a CPU!