Contiguous memory guarantees with C++ function parameters

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.

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;
}

foo(1,2,3,4);

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.

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.

There is nothing in the standard about calling conventions or how parameters are passed.

It is true that if you take the address of one variable (or parameter) that one has to be stored in memory. It doesn't say that the value cannot be passed in a register and then stored to memory when its address is taken.

It definitely doesn't affect other variables, who's addresses are not taken.

The C++ standard has no concept of a calling convention. That's left for the compiler to deal with.

In this case, if the standard requires that parameters be contiguous when the address-of operator is applied, there's a conflict between what the standard requires of your compiler and what you require of it.

It's up to the compiler to decide what to do. I'd think most compilers would give your requirements priority over the standard's, however.

Your basic assumption is flawed. On my machine, foo(1,2,3,4) using your code prints out:

1 -680135568 32767 4196336

Using g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3 on 64-bit x86.