C Program Memory Layout

1. The Five Main Memory Segments

When a C program is executed, the operating system allocates a virtual address space for it, which is typically organized into five main segments. Having a clear picture of these segments is fundamental.

To get a quick and clear overview, please watch the first four minutes of the following video. It introduces the five key segments we'll be discussing.

The layout discussed in the video can be visualized with this classic diagram:

Let's break down each of these segments.

• Text Segment (or Code Segment)

  • What it is: This is where the compiled machine code of your program resides. It contains the instructions for all your functions (like main, and any other functions you've written or linked from libraries).
  • Key Property: It is typically marked as read-only. This is a security feature to prevent a program from accidentally or maliciously modifying its own instructions during execution.

• Initialized Data Segment (often just called .data)

  • What it is: This segment stores all global, static, and extern variables that are initialized with a non-zero value when you declare them.
  • Example: int max_connections = 100; or static float PI = 3.14159;
  • The initial values for these variables are stored directly in the executable file on disk.

• Uninitialized Data Segment (or BSS Segment)

  • What it is: BSS stands for "Block Started by Symbol," a historical name from an old assembler. This segment holds all global and static variables that are not explicitly initialized, or are initialized to zero.
  • Example: int global_counter; or static char command_buffer[1024];
  • Key Property: The C standard guarantees that variables in this segment are automatically initialized to zero by the C runtime system before main() is called.
  • Interview Tip: A common interview question is, "Why have a separate BSS segment instead of just putting everything in the data segment?" The reason is efficiency. For a large uninitialized array like int big_array[100000];, the executable file doesn't need to store 400KB of zeros. It only needs to record the size of the BSS segment. The operating system then allocates a block of zero-filled memory at runtime, keeping the executable file much smaller.

• Heap

  • What it is: This region is for dynamic memory allocation. It's the memory you, the programmer, manage manually using functions like malloc(), calloc(), and free().
  • Key Property: The heap is flexible and grows as you request memory. In the standard memory model, it grows upward (towards higher memory addresses). You are responsible for freeing any memory you allocate; failing to do so results in a memory leak.

• Stack

  • What it is: This segment is used to manage function calls. Each time a function is called, a "stack frame" is pushed onto the stack. This frame contains the function's local variables, its parameters, and the return address (where to go back to when the function finishes).
  • Key Property: The stack is managed automatically in a Last-In, First-Out (LIFO) manner. It grows and shrinks as functions are called and return. It's very fast, but its size is limited. On most systems, it grows downward (towards lower memory addresses).

2. Seeing It in Action: Where Variables Live

Let's solidify this with a comprehensive code example. The following reading contains a well-commented C program that declares variables of every kind and then prints their memory addresses, allowing you to see the memory layout in action.

This table summarizes the key distinctions for interview purposes:

3. From Abstract Model to Embedded Reality

The model we've discussed is the abstract C standard. Your experience in AUTOSAR and embedded systems programming gives you a practical perspective that is very valuable. In embedded systems, these abstract segments are physically mapped onto hardware, typically Flash (ROM) and RAM.

This next video bridges that gap. It's quite detailed, but we'll focus on the parts that are most relevant to your background.

This startup process is a key difference between a program running on a host OS (like Windows/Linux) and a bare-metal or RTOS-based embedded system. Knowing this demonstrates a deep understanding that goes beyond textbook C.

• Executable Image in Flash: The .text (code), .rodata (read-only data like const variables and string literals), and the initial values for the .data segment are stored in non-volatile Flash memory.
• Runtime in RAM: At boot, the startup code (which runs before main):
  1. Copies the contents of the .data segment from Flash to RAM.
  2. Zeros out the entire .bss segment in RAM.
  3. Sets up the stack pointer.
  4. Initializes the heap, if used.
  5. Finally, calls main().

4. Self-Assessment

Let's test your understanding. For the following C code snippet, identify which memory segment each numbered variable or piece of data is stored in.

#include <stdio.h>
#include <stdlib.h>

const int FIRMWARE_VERSION = 2;       // 1. Where is 2 stored?
char* status_message = "OK";          // 2. Where is the pointer `status_message`?
                                      // 3. Where is the string literal "OK"?

long event_counter;                   // 4. Where is `event_counter`?

void process_event(int event_id) {
    static int processed_count = 0;   // 5. Where is `processed_count`?
    char local_buffer[32];            // 6. Where is `local_buffer`?
    
    int* log_data = malloc(16);       // 7. Where is `log_data` (the pointer itself)?
                                      // 8. Where is the 16-byte block of memory it points to?
    
    // ... function logic
    free(log_data);
}

Conclusion

In this lesson, we've reviewed the canonical memory layout of a C program.

Key Takeaways:

• A C program's memory is segmented into Text, Data, BSS, Heap, and Stack.
• The storage duration (lifetime) and scope of a variable are determined by where it is declared and what keywords (static, etc.) are used, which in turn determines its memory segment.
• Globals and statics live for the entire program duration (in .data or .bss).
• Locals live only for the duration of a function call (on the stack).
• Dynamically allocated memory lives until manually freed (on the heap).
• In embedded systems, these segments are physically mapped to hardware like Flash and RAM, with a specific startup routine handling initialization before main().

This mental model is the foundation for almost every other topic in our course. In the next lesson, we will zoom in on the Stack and explore the function call mechanism, stack frames, and the passing of parameters in more detail.