MEMORY LAYOUT IN C PROGRAMING
Process address space is organized into three memory areas, called segments: the text segment, stack segment, and data segment (bss and data) and can be illustrated below.
Text segment or code segment -
Where your program code (in assembly code format) will be stored.
Initialized data – data segment
Statically allocated and global data
that are initialized with nonzero values live in the data
segment. Each process running the same program has its
own data segment. The portion of the executable file containing
the data segment is the data section.
Uninitialized data – bss segment
BSS stands
for ‘Block Started by Symbol’. Global and statically
allocated data that initialized to zero by default are kept
in what is called the BSS area of the process. Each process
running the same program has its own BSS area. When running,
the BSS, data are placed in the data segment. In the executable
file, they are stored in the BSS section. For Linux/Unix
the format of an executable, only variables that are initialized
to a nonzero value occupy space in the executable’s disk file.
Heap
The heap is where dynamic memory (obtained
by
malloc(),
calloc(),
realloc()
and
new
– C++) comes from. Everything on
a heap is anonymous, thus you can only access parts of it through
a pointer. As memory is allocated on the heap, the process’s
address space grows. Although it is possible to give memory
back to the system and shrink a process’s address space, this is
almost never done because it will be allocated to other process
again. Freed memory (free() and
delete
– C++) goes back to the heap, creating what is called holes.
It is typical for the heap to grow upward. This
means that successive items that are added to the heap are added
at addresses that are numerically greater than previous items.
It is also typical for the heap to start immediately after the BSS
area of the data segment. The end
of the heap is marked by a pointer known as the
break. You
cannot reference past the break. You can, however, move the break
pointer (via
brk()
and
sbrk()
system calls) to a new position to increase the amount of heap memory
available.
Stack
The stack segment is where local (automatic)
variables are allocated. In C program, local variables are
all variables declared inside the opening left curly brace of a
function's body including the
main()
or other left curly brace that aren’t defined as static. The
data is popped up or pushed into the stack following
the Last In First Out (LIFO) rule. The stack holds
local variables, temporary information, function parameters, return
address and the like. When a function is called, a stack
frame (or a procedure activation record) is created and
PUSHed
onto the top of the stack. This stack frame contains information
such as the address from which the function was called and where
to jump back to when the function is finished (return address),
parameters, local variables, and any other information needed by
the invoked function. The order of the information may vary by system
and compiler. When a function returns, the stack frame is
POPped
from the stack. Typically the stack grows downward, meaning
that items deeper in the call chain are at numerically lower addresses
and toward the heap.
ANOTHER EXAMPLE
//test.c file
int global_var1 = 10; ==> data segement
int main()
{
int local_var1 = 5; ==> stack
static int local_var2 = 20; ==> data segement
int * dynamic_var3 = malloc(sizeof(int) * 5); ==> heap
printf (“all done!”);
return 0;
0 comments:
Post a Comment
Dont Forget for Commets