Stack allocation in a function call

Question

When you call a function, arguments that are passed to the function are passed-by-value if they are not arrays or not deliberately passed-by-reference with the ampersand (&) symbol. For instance,

void boo (int a, int b) {}

int main() {
    int var1 {1};
    int var2 {2};

    boo(var1,var2);

    return 0;
}

In this scenario, values of the integer variables var1 and var2 are copied to the function parameters a and b and stored in the stack frame allocated for the boo() function. My questions are:

If I write

void boo (int a, int b) {}

int main() {
    boo(1,2);

    return 0;
}

are the integer literals 1 and 2 not stored in the main() stack frame since they are now r-values?

If I instead write

void boo (int &a, int &b) {}

int main() {
    int var1{1};
    int var2{2};

    boo(var1,var2);

    return 0;
}

are the parameters a and b still stored in the stack frame of the boo() function as a some kind of a back-up etc. Or are they only references to the actual parameters var1 and var2 now?

Answer 1

The code you write is not instructions for your cpu. It is instructions for your compiler. After reading this answer you might argue that your code was just a simplified example, but same as your compiler I can only work with what you provide. The compiler turns your code into machine instructions that have the observable behavior as specified for your code in the c++ standard.

Your code:

void boo (int a, int b) {
}

int main() {

    int var1 {1};
    int var2 {2};

    boo(var1,var2);

    return 0;
}

Has exactly the same observable behavior as this one:

int main() {}

The integer literals must not be stored anywhere. They need not even appear in the executable binary. The same is true for the other code examples in your code. For more details I refer you to What exactly is the "as-if" rule? and Storage of literal constants in c++.

---

For the sake of illustration, consider a different example:

int main() {
    return [](int x){
        int sum = 0;
        for (int i=0;i<x;++i) sum += i;
        return sum;
    }(5);
}

Rather than discussing it on a language-lawyer basis, I hope it suffices as demonstration that gcc with optimizations turned on procudes the following output:

main:
        mov     eax, 10
        ret

The literal 5 is not stored anywhere. If you like you can experiment with passing int x = 5; to the lambda, it will not make a difference. As PaulMcKenzie mentions in a comment, you can turn the lambda with the loop into a recursive function and you will still see the same effect: No 5 anywhere.

Gcc correctly realized that the observable behavior of the above code is (in plain english terms): "return 10 from main", hence it produced output that does that. Now you ask "where is the 5 stored?" But the code is just a convoluted way to describe returning 10 from main and that needs no 5 stored anywhere.