In this article, 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,assuming that the programmer knows what they are doing.
Thus, C is actually a language that demands a lot from programmers.
Decades later, 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 features 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, small-capacity storage units within the processor,and 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 occur.
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 operational state (e.g., whether the result of a calculation is zero, whether a carry has occurred, etc.)
- Controlling the flow of program execution (e.g., the address of the next instruction)
Next, let’s look at physical memory.
Physical memory, usually referring to the main storage (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 running state of the program (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 embedding assembly instructions directly 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 support for inline assembly, with the basic syntax as follows:
// Store the value of the EAX register into the result variable
asm volatile ("movl %%eax, %0" : "=r"(result) : );
// Load the value of the variable value into the 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> blocks 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 seen 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 undergo 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 in user mode, although pointers can be used, they operate on virtual memory, 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 abstraction 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
High-quality original review
The most difficult IT companies to get hired in China…
Elon Musk sent a private message asking a beautiful internet celebrity to have his child, and after being rejected, cut off her $21,000 bi-weekly advertising income?
A colleague from outsourcing attended a dinner, and just as he arrived at the door of the private room, he heard the supervisor say: We are all insiders, in the future, any dirty or tiring work will be given to outsourcing, they are here to serve us, so don’t feel embarrassed.
After leaving the job and handing over, a bug appeared online, and the interface was developed by himself, the n+1 compensation was reclaimed.
I’ve heard that the internet doesn’t hire people over 35 anymore?
Programmers are starting to engage in “defensive programming” to protect their jobs…..
This move by ByteDance directly changed everyone’s habits?
A Huawei employee revealed: Most people in OD are at their peak upon joining! Level D4, except for a 3k monthly salary increase when promoted to D5, it has never increased at any other time.
Don’t forget to share, bookmark, view, and like!