Thread: How would these variables get pushed on to the stack?

As far as I know, the stack is a region in RAM that stores local variables created by each function (including the main() function). The stack is a "LIFO" (last in, first out) data structure that is managed and optimized by the CPU quite closely. Every time a function declares a new variable, it is "pushed" onto the stack. Then every time a function exits, all of the variables pushed onto the stack by that function, are freed (that is to say, they are deleted). Once a stack variable is freed, that region of memory becomes available for other stack variables.

So consider the following code sample:

Code:

#include <stdio.h>


double multiplyByTwo (double input) 
{
  double twice = input * 2.0;
  return twice;
}


int main (int argc, char *argv[])
{
  int age = 30;
  double salary = 12345.67;
  double myList[3] = {1.2, 2.3, 3.4};


  printf("double your salary is %.3f\n", multiplyByTwo(salary));


  return 0;
}

How would the variables shown above be added to the stack and which is the last that goes? From what I know, the variables in int main are pushed on to the stack first since main() is where the program starts. But which variable does first, then is pushed out? Do the variables in multiplyByTwo() go last?

The actual ordering doesn't matter, just as long as they are consistent. That is wath optimizing compilers do.

For sample, as age and myList[] are not used, they won't even end up on the stack - the compiler will say "unused variable" and ignore them.

But in general variables are added in the order they appear (or maybe more correctly enter and exit scope), and when making function calls parameters are pushed onto the working from first to last (i.e. the last parameter will be on the top of the stack).

This is all a first approximation as the calling conventions for different CPUs and OSs specify that you pass the first few parameters and results using the CPU's internal registers.

Unless you are compiling your code without any optimizations enabled, the compiler will use the stack to store local variables only if needed. In general, for optimized code, the compiler uses registers. Here's your example, compiled for x86-64:

Code:

; 'twice' is eliminated!
; This function is here only because isn't 'static'.
multiplyByTwo:
    addsd    xmm0, xmm0
    ret

; 'age' and 'mylist[]' are eliminated.
; main() never uses 'multiplyByTwo' function!
main:
    sub    rsp, 8
    mov    edi, 1
    mov    eax, 1
    movsd    xmm0, QWORD PTR [.LC0]
    lea    rsi, [.LC1]
    call    __printf_chk@PLT
    xor    eax, eax
    add    rsp, 8
    ret

    section    .rodata
.LC1:
  db  "double your salary is %.3f\n",0
.LC0:
  ; The compiler knows it must multiply 12345.67 by 2, so it does at compile time.
  dq  24691.34

Notice the compiler never alocated any of your 'local' variables on stack (and never called your multiplyByTwo() function on main()).