Memory Layout of a C Program - Stack Wise

high high --------------

        |               |

        | Arguments and |

        |  environment  |

        |   variables   |

        |               |

        |---------------|

        |     Stack     |<--|--

        |(grow downward)|   |

        |               |   |User

        |               |   |Stack

        |               |   |Frame

        |               |   |

        | (grow upward) |   |( Mind the Gap )

        |      Heap     |<--|--

        |---------------|

        |      BSS      |<-- uninitialized static data(block started by symbol)

         |               |      long  sum[1000];

        |---------------|

        |      Data     |<-- initilized static data(int   maxcount = 99)

        |---------------|

        |      Code     |<-- text segment machine instructions

    low

Stack : where automatic variables are stored, along with information that is
saved each time a function is called. Each time a function is called, the
address of where to return to and certain information about the caller's
environment, such as some of the machine registers, are saved on the stack. The
newly called function then allocates room on the stack for its automatic and
temporary variables. This is how recursive functions in C can work. Each time a
recursive function calls itself, a new stack frame is used, so one set of
variables doesn't interfere with the variables from another instance of the
function.
Text Segment: The text segment contains the actual code to be executed. It's
usually sharable, so multiple instances of a program can share the text segment
to lower memory requirements. This segment is usually marked read-only so a
program can't modify its own instructions.
Initialized Data Segment: This segment contains global variables which are
initialized by the programmer.
Uninitialized Data Segment: Also named "bss" (block started by symbol) which
was an operator used by an old assembler. This segment contains uninitialized
global variables. All variables in this segment are initialized to 0 or NULL
pointers before the program begins to execute.
The stack: The stack is a collection of stack frames which will be described in
the next section. When a new frame needs to be added (as a result of a newly
called function), the stack grows downward.
Every time a function is called, an area of memory is set aside, called a stack frame,
for the new function call. This area of memory holds some crucial information, like:
1. Storage space for all the automatic variables for the newly called function.
2. The line number of the calling function to return to when the called function
returns.
3. The arguments, or parameters, of the called function.
The heap: Most dynamic memory, whether requested via C's malloc() and friends
or C++'s new is doled out to the program from the heap. The C library also gets
dynamic memory for its own personal workspace from the heap as well. As more
memory is requested "on the fly", the heap grows upward.