Contiguous memory guarantees with C++ function parameters

Question

Appel [App02] very briefly mentions that C (and presumably C++) provide guarantees regarding the locations of actual parameters in contiguous memory as opposed to registers when the address-of operator is applied to one of formal parameters within the function block.

e.g.

void foo(int a, int b, int c, int d)
{
    int* p = &a;
    for(int k = 0; k < 4; k++)
    {
       std::cout << *p << " ";
       p++;
    }
    std::cout << std::endl;
}

and an invocation such as...

foo(1,2,3,4);

will produce the following output "1 2 3 4"

My question is "How does this interact with calling conventions?"

For example __fastcall on GCC will try place the first two arguments in registers and the remainder on the stack. The two requirements are at odds with each other, is there any way to formally reason about what will happen or is it subject to the capricious nature of implementation defined behaviour?

[App02] Modern Compiler Implementation in Java, Andrew w. Appel, Chapter 6, Page 124

Update: I suppose that this question is answered. I think I was wrong to base the whole question on contiguous memory allocation when what I was looking for (and what the reference speaks of) is the apparent mismatch between the need for parameters being in memory due the use of address-of as opposed to in registers due to calling conventions, maybe that is a question for another day.

Someone on the internet is wrong and sometimes that someone is me.

Answer 1

First of all your code doesn't always produce 1, 2, 3, 4. Just check this one: http://ideone.com/ohtt0 Correct code is at least like this:

void foo(int a, int b, int c, int d)
{
    int* p = &a;
    for (int i = 0; i < 4; i++)
    {
        std::cout << *p;
        p++;
    }
}

So now let's try with fastcall, here:

void __attribute__((fastcall)) foo(int a, int b, int c, int d)
{
    int* p = &a;
    for (int i = 0; i < 4; i++)
    {
        std::cout << *p << " ";
        p++;
    }
}

int main()
{
        foo(1,2,3,4);
}

Result is messy: 1 -1216913420 134514560 134514524

So I really doubt that something can be guaranteed here.