What creates the stack?

Suppose in a program we have implemented a开发者_如何学运维 stack. But who creates the stack ? Is it the processor, or operating system, or compiler?

Are you confusing the programs execution stack with the stack container?

You can't "implement" the execution stack, the OS will give you Virtual Address Space and locate there your stack pointer, so you just push and pop from it, you don't "create it", its there when you start.

If you mean the data structure: The processor executes the code. The code makes calls to the operating system to get the memory for the stack, and then manipulates it to form it into a stack. The compiler just turns the code you wrote into code the processor can understand.

If you mean the execution stack: The OS is responsible for loading a process into memory and setting up its memory space to form the stack.

Your program... it performs the required assembly. That assembly was inserted by the compiler in place of the function/function call based on the calling convention being used.

Learning about calling conventions would probably be the most effective way to answer your question.

None of the above. YOU created it when you implemented it. The compiler only translates your thoughts (expressed in a programming language) into machine or assembly code. The processor only runs that program that you wrote. The operating system (assuming one exists), provides mechanisms to facilitate giving you an execution space and memory to do it, but YOUR PROGRAM determines what happens in that execution space and memory.

If you want to implement a stack of your own, try using std::stack<>. If you're talking about the stack that local variables are on, that's created by the C++ runtime system.

"Suppose in a program we have implemented a stack."

Then you implemented it on the underlying, low level data structure like for example array. Your stack = array + functions (push(), pop()) working on an array to provide stack functionality.

"But who creates the stack ? Is it the processor, or operating system, or compiler?"

And who creates functions and array? Functions are created by you, then compiler translates functions to machine instructions and keeps this code in executable. Additionaly it produces a set of instructions to allocate some space in the memory for your array. So your program is a mix of instructions and space for an array. Then operating system loads your program and sends instructions to the processor. Processor performs this instructions and reads/writes data to your array.

Say you have a test C program:

int square( int val ) {
    int result;

    result = val * val;
    return( result );
}

int main( void ) {
    int store;

    store = square( 3 );
    return( 0 );
}

then you can produce the assembler output produced by the compiler using the command
gcc -S test.c -o test.s
(if you're on a Linux platform).

Looking at the generated code for just the square() function we get:

square:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $16, %esp
        movl    8(%ebp), %eax
        imull   8(%ebp), %eax
        movl    %eax, -4(%ebp)
        movl    -4(%ebp), %eax
        leave
        ret

You can see that the compiler has generated code to move the stack pointer for the local variables in the routine.

The initialisation code for your program will have allocated a certain amount of memory for "the stack" by calling system (Operating Systems) memory allocation functions. Then it is up to the compiled program to choose how to utilise that area of memory.

Fortunately for you all of this is effectively handled by the compiler without you having to think about it (unless, of course, you're likely to have local variables that are too big for a standard stack size, in which case you may have to instruct your compiler, or thread library, to allocate more stack from the system).

Suppose in a program we have implemented a stack. But who creates the stack ?

Well if you implemented it, then by definition you created it. You need to be more specific w.r.t. context.

The standard runtime library or the linker-loader creates the stack. It is done in a little section of code that runs before your main. This code is inserted automatically by the linker when you link and it runs at runtime, setting up various things before your main is called, for example any statically initialized global variables. It usually sets up the stack too, although some OSes put this into OS code (the linker-loader) because they want to standardize stack implementation/shape on their systems.

the stack is embedded in the processor, it is the esp register, you need to learn a little win32 assembly programming in order to understad the stack

A stack is a Last In First Out (LIFO) list data structure. The stack is created by the program execution where the variables are stored, deleted as per the program execution requirement.