Architecture & Basics: The C Runtime

C is often called "portable assembly" because it provides a thin abstraction over the underlying hardware. To master C, you must understand how a program interacts with the CPU and Memory.

The Compilation Pipeline

In an industry setting, C code isn't just "run". It goes through a rigorous transformation:

1. Preprocessing: Handling #include, #define, and macros.
2. Compilation: Translating C to Assembly.
3. Assembly: Converting assembly to machine code (Object files).
4. Linking: Combining object files and libraries into a final executable.

Memory Layout of a C Program

Every C process in a modern OS has a specific memory layout:

• Text Segment: Contains the executable instructions (Read-only).
• Data Segment: Initialized global and static variables.
• BSS Segment: Uninitialized global variables (Zero-filled).
• Heap: Dynamic memory (grows upwards).
• Stack: Local variables and function calls (grows downwards).

c code
#include <stdio.h>

int global_var = 10; // Data Segment
int uninit_var;      // BSS Segment

int main() {
    int local_var = 5; // Stack Segment
    static int static_var = 20; // Data Segment
    
    printf("C Architecture Mastery\n");
    return 0;
}

Data Types and Platform Dependencies

Industry-grade C often uses stdint.h to ensure portability. Standard types like int can vary in size (16, 32, or 64 bits) depending on the architecture.

c code
#include <stdint.h>

int32_t fixed_int = 100; // Guaranteed 32-bit
uint64_t large_val = 5000000000ULL; // Guaranteed 64-bit unsigned

Why this matters?

In embedded systems or high-performance networking, knowing the exact byte alignment and size is critical for cache optimization and protocol adherence.