sourav punoriyar

 Profile Answers by sourav punoriyar 

• Sep 5th, 2013

 

all the above code is in the code section of memory...as int a;a=5;are automatic storage class type..so they will come to life when this function is called.as local variables are stored in stack section so...memory will be given in the function frame created for this function...all values gets destroyed when function returns and collapse....

jbode

 Profile Answers by jbode Questions by jbode

• Sep 19th, 2014

 

See the attached snippet for a general picture of how a compiled program is loaded into memory for x86-based systems. Some architectures (such as Harvard architecture) dont store program text and data together in the same memory, so those layouts will be different. But this should be good enough to answer your question in a general sense.

The C programming language defines three storage durations for objects in memory. Objects with automatic storage duration (i.e., local variables within a function) have storage set aside when you enter their enclosing scope (function or block), and that storage is released when you exit that scope. Objects with static storage duration (i.e., variables declared at file scope or with the static keyword) have storage set aside when the program is first loaded into memory (even before main executes), and that storage is released when the program exits. Objects with dynamic storage duration have storage set aside when you call one of malloc, calloc, or realloc, and that storage is released when you call free.

Note that I use the term "storage" instead of "memory"; Im talking about memory in the virtual, logical sense, not in terms of physical RAM.

So how do those storage durations map to the image below? The segment "Initialized data" is used for read-only data like string literals and const-qualfied static variables. These items are stored in the compiled binary file itself, so they appear in memory as soon as the program is loaded. The segment "Uninitialized data" is used for global variables that may or may not have an initial value, and are writable. Again, this space is set aside in the compiled binary file itself, so that memory is available as soon as the program is loaded. If theres no explicit initializer for those items, they will be initialized to 0 or NULL.

The stack is used to store objects with automatic storage duration; each time a function is called, a new stack frame is created on the stack. Each stack frame stores the arguments passed to the function and any local variables, along with the return address (that is, the address of the next instruction following the function call).

There are usually two registers associated with the stack. One is the stack pointer, and it contains the address of the last item pushed onto the stack. The other is the frame pointer, and it points to the overall frame (typically, it points to the address just below the last function argument). If you look at the generated machine code, youll see that function arguments and local variables are referred to by their offset from the frame pointer.

The heap is used to store objects with dynamic storage allocation; basically, anything created with malloc, calloc, or realloc. Note that there is a difference between the allocated object and the pointer variable that refers to that object. Given a declaration like "T *p = malloc( sizeof *p );", the variable "p" lives on the stack, but the object it points to lives on the heap. When you exit the function, the space for "p" will automatically be deallocated when the stack frame is popped off the stack, but the memory it pointed to will still be allocated until someone calls free on it.

Code
General program layout in memory:


 


             +-----------------+


High address |    Arguments,   |  Contents of argv array


             |   environment   |


             |    variables    |


             +-----------------+


             |      Stack      |  Automatic (local) variables


             |     .......     |


             |        |        |


             |        V        |


             |        ^        |


             |        |        |


             |     .......     |  Dynamically allocated memory (malloc/calloc/realloc)


             |       Heap      |


             +-----------------+


             |  Uninitialized  |  Non-const static (global) variables


             |      data       |


             +-----------------+


             |   Initialized   |  String literals, const-qualified static


             |      data       |  variables  


             +-----------------+


             |   Program text  |  Functions (including main())


Low address  |  (machine code) |       


             +-----------------+ 


 


Stack frame:


           


             +-----------------+


High address | Function args   |


             |        .        |


             |        .        |


             |        .        |


             +-----------------+


             |  Return address | <-- Frame pointer


             +-----------------+


             | Local variables |


             |        .        |


             |        .        |


Low address  |        .        | <-- Stack pointer


             +-----------------+


 


Sample program:


 


    #include <stdio.h>


    


    void foo( void )


    {


      printf( "foo


" );


    }


 


    void bar( void )


    {


      foo();


    }


 


    int main( void )


    {


      bar();


      return 0;


    } 


 


When the program first enters the foo function, the stack will look


something like this:


 


             +-----------------+


High address | Previous frame  | stack frame for main


             +-----------------+


             | Previous frame  | stack frame for bar


             +-----------------+


             |  Current frame  | stack frame for foo


             +-----------------+


             | Available stack | will be used by printf 


             |      memory     |     


             |        .        |


             |        .        |


Low address  |        .        |


             +-----------------+