What does “Memory allocated at compile time” really mean?

by

Memory allocated at compile-time means the compiler resolves at compile-time where certain things will be allocated inside the process memory map.

For example, consider a global array:

int array[100];

The compiler knows at compile-time the size of the array and the size of an int, so it knows the entire size of the array at compile-time. Also a global variable has static storage duration by default: it is allocated in the static memory area of the process memory space (.data/.bss section). Given that information, the compiler decides during compilation in what address of that static memory area the array will be.

Of course that memory addresses are virtual addresses. The program assumes that it has its own entire memory space (From 0x00000000 to 0xFFFFFFFF for example). That’s why the compiler could do assumptions like “Okay, the array will be at address 0x00A33211”. At runtime that addresses are translated to real/hardware addresses by the MMU and OS.

Value initialized static storage things are a bit different. For example:

int array[] = { 1 , 2 , 3 , 4 };

In our first example, the compiler only decided where the array will be allocated, storing that information in the executable.
In the case of value-initialized things, the compiler also injects the initial value of the array into the executable, and adds code which tells the program loader that after the array allocation at program start, the array should be filled with these values.

Here are two examples of the assembly generated by the compiler (GCC4.8.1 with x86 target):

C++ code:

int a[4];
int b[] = { 1 , 2 , 3 , 4 };

int main()
{}

Output assembly:

a:
    .zero   16
b:
    .long   1
    .long   2
    .long   3
    .long   4
main:
    pushq   %rbp
    movq    %rsp, %rbp
    movl    $0, %eax
    popq    %rbp
    ret

As you can see, the values are directly injected into the assembly. In the array a, the compiler generates a zero initialization of 16 bytes, because the Standard says that static stored things should be initialized to zero by default:

8.5.9 (Initializers) [Note]:
Every object of static storage duration is zero-initialized at
program startup before any other initial- ization takes place. In some
cases, additional initialization is done later.

I always suggest people to disassembly their code to see what the compiler really does with the C++ code. This applies from storage classes/duration (like this question) to advanced compiler optimizations. You could instruct your compiler to generate the assembly, but there are wonderful tools to do this on the Internet in a friendly manner. My favourite is GCC Explorer.

More Related Contents:

  1. Dynamic memory allocation in game server [closed]
  2. When and why will a compiler initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
  3. General guidelines to avoid memory leaks in C++ [closed]
  4. Allocating more memory than there exists using malloc
  5. How do you determine the size of an object in C++?
  6. What is the behavior of “delete” with stack objects? [duplicate]
  7. What is “bit padding” or “padding bits” exactly?
  8. How do I call the original “operator new” if I have overloaded it?
  9. Is global memory initialized in C++?
  10. Class members and explicit stack/heap allocation
  11. drawbacks of using new/delete in ANSI C [closed]
  12. convert malloc to new c++ for struct
  13. Determine the size of a C++ array programmatically?
  14. Will new return NULL in any case?
  15. The differences between initialize, define, declare a variable
  16. stringstream, string, and char* conversion confusion
  17. Memory alignment in C-structs
  18. Making std::vector allocate aligned memory
  19. How to know if a pointer points to the heap or the stack?
  20. Global scope vs global namespace
  21. C++11 lambda implementation and memory model
  22. What happens when you deallocate a pointer twice or more in C++?
  23. Best way for interprocess communication in C++
  24. Since I can’t return a local variable, what’s the best way to return a string from a C or C++ function?
  25. How is heap and stack memories managed, implemented, allocated?
  26. Does this type of memory get allocated on the heap or the stack?
  27. What is a jump table?
  28. What is an opaque value in C++?
  29. C: pointer to array of pointers to structures (allocation/deallocation issues)
  30. Memory management patterns in C++

Leave a Comment