Thread: Memory allocation at compile time

Consider this example

Code:

#include <stdio.h>
#include <stdlib.h>
int data[10] = { 0,1,2,3,4,5,6,7,8,9 };
char large[1000];
int main ( ) {
    void *p = malloc(100);
    printf("%d %d\n", data[0], large[0]);
    free(p);
}

$ gcc foo.c
$ size a.out 
   text	   data	    bss	    dec	    hex	filename
   1600	    672	   1032	   3304	    ce8	a.out

When the OS is told to load and run the program, it examines this information about your program.
text is where your program code resides. 1600 bytes(*) is allocated by the OS and initialised with the program code from the file. In most OS's, this is made read-only/executable after initialisation.
data is where initialised data (such as the array called data) resides. This too is copied from the file.
bss is also for data, but for anything which is default initialised to all zeros (such as the array called large). Only the size is stored in the file, as it's pointless to read a whole bunch of zeros when all the OS has to do is memset.

Behind the scenes, you also get a stack and a heap for runtime use (calling functions, allocating memory).

So at the point your main starts executing, the OS has allocated and initialised memory for your program code, your global data, given you a stack and created a heap for future dynamic memory allocations.

This you immediately make use of by calling malloc.


(*) sizes are typically rounded up to some multiple of the page size.

No memory at all gets allocated at compile time.

Memory is only allocated when the program is actually run.

What happens at compile time though is the compiler saying
"I want x bytes of memory reserved for a variable named globalVar"
"I want y bytes of memory reserved for a function called main"
etc
etc

In essence, it's more like "memory is reserved" by the compiler.

Look at the assembler generated by your code.

Code:

$ gcc -S foo.c
$ head -50 foo.s
	.file	"foo.c"
	.text
	.globl	globalVar
	.data
	.align 4
	.type	globalVar, @object
	.size	globalVar, 4
globalVar:
	.long	10
	.align 4
 	.type	staticGlobalVar, @object
	.size	staticGlobalVar, 4
staticGlobalVar:
	.long	20
	.section	.rodata
.LC0:
	.string	"Memory allocation failed."
.LC1:
	.string	"Global variable: %d\n"
.LC2:
	.string	"Static global variable: %d\n"
.LC3:
	.string	"Local variable: %d\n"
.LC4:
	.string	"Static local variable: %d\n"
.LC5:
	.string	"Dynamic variable: %d\n"
.LC6:
	.string	"Extern variable: %d\n"
	.align 8
.LC7:
	.string	"Pointer variable (points to globalVar): %d\n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB6:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$32, %rsp
	movl	$5, -20(%rbp)
	movl	$4, %edi
	call	malloc@PLT
// snipped

> it say memory allocation can also done before execution of program
If you're running on a machine without an OS, then that's likely true.

But allocation is perhaps the wrong word here.

It would perhaps be better to say each object (with global scope) is assigned a memory location, which in principle, you can decide where that is.

Certainly, dynamic allocation is memory you get at runtime through some action of your program deciding that it needs to allocate some memory.

As for the rest, well it depends on your point of view.

Memory for say a global variable needs a memory location defined at some point.

If you're writing bare metal code where your code is burned into a ROM, the location is decided before you even switch on the machine. It's fixed in the ROM.

But if your program is loaded by an OS of some sort, the program file indicates how much memory it needs to begin with, and the OS allocates that memory for use by your program.
By the time code execution hits your main(), the OS will have done all the initial work for you.

Kittu20:

Global variables, static variables, and local variables are defined in the code when the code is compiled.

Memory for globals and static variables are actually allocated when the program is loaded into memory when the program is executed.

Memory for Local variables are allocated in the stack frame when the function is called.

Dynamic memory allocation is done with the functions, malloc(), and calloc(). The "heap" is an area of memory that is allocated when the program is executed, but the memory is not in use until malloc() or calloc() is called.

Calls to either function, allocates a portion of the heap, and assigns to a pointer. That memory can then be used by the program through the pointer, until the address returned by either function is passed to free() to free up the memory, and then is available for a subsequent allocation later in the program.

Please see the manpage for malloc() and related functions.

To fully understand this and all the other details of the C Programming Language, can be learned through studying a good up-to-date book on the language.


If you are attempting to learn from painfully inadequate online tutorials, YouTube videos, or some book claiming to teach you in a short time, then THROW THEM AWAY!

Short of taking a course in C Programming from a qualified instructor, you need to study a good book on the C Programming Language, cover to cover, and do all the exercises at the end of each chapter! Choose one of the three listed below:

C Programming, A Modern Approach, 2nd Edition
Author: K. N. King

C Primer Plus, 6th Edition
Stephen Prata

C How to Program, 8/e
Deitel & Deitel

Studying one of these books, doing the exercises, and writing code, you will have a much better understanding of the C Programming language.