Why is there a 4 byte gap between the parameters on Microsoft VC++

Question

I have the following program that I am compiling using Microsoft's Visual C++ command line compiler.

#include<stdio.h>

void foo(int, int);

void main(void) {

    foo(5,4);
}

void foo(int a, int b) 
{
    printf("%u\n", sizeof(int));
    printf("%u\n", &a);
    printf("%u\n", &b);
}

When I print out the addresses I get addresses like -:

3799448016
3799448024

The gap is always 8 byes between addresses, while sizeof(int) = 4

There is always an extra 4 byte gap between the parameters (The size of int on my machine is 4 bytes). Why ?

What is the extra 4 bytes of space for ?

I am on a 64-bit Windows 8.1 machine with VS 2013.

Answer 1

Well, I cannot check the code produced by VS 2013, but Godbolt does support some CL version; the assembly below is an excerpt of what it generated:

main    PROC
        sub      rsp, 40              ; 00000028H
        mov      edx, 4
        mov      ecx, 5
        call     void __cdecl foo(int,int)
        ...
main ENDP

a$ = 48
b$ = 56
foo PROC
        mov      DWORD PTR [rsp+16], edx
        mov      DWORD PTR [rsp+8], ecx
        sub      rsp, 40              ; 00000028H
        mov      edx, 4
        lea      rcx, OFFSET FLAT:$SG4875
        call     printf
        lea      rdx, QWORD PTR a$[rsp]
        lea      rcx, OFFSET FLAT:$SG4876
        call     printf
        lea      rdx, QWORD PTR b$[rsp]
        lea      rcx, OFFSET FLAT:$SG4877
        call     printf
        add      rsp, 40              ; 00000028H
        ret      0
foo ENDP

First of all, the parameters are not passed on stack, but in registers - first in *CX and second in *DX - as these are 32-bit, they're passed in EDX and ECX .

Thus, the parameters do not have addresses, and would not stored in memory, unless they have their address taken. Since the & operator is used within the function, these now have to be stored on stack. I don't have any good explanation though on why they're stored with a 4-byte gap ([rsp+16] and [rsp+8]) - but they are. **EDIT: Here's the relevant Visual Studio documentation - from Hans Passant's comment - it clearly shows that VS 2013 uses a fixed layout to store the parameters wherever needed - despite their types.

This is unlike my Linux GCC, which would generate code that stores them in adjacent 32-bit locations:

foo:
.LFB1:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR -4[rbp], edi
        mov     DWORD PTR -8[rbp], esi

...

And the conversion specification for printing pointers is %p and for size_t you should use %zu. But since VS 2013 does not have a standards-compliant C compiler, you cannot use z - therefore cast it to unsigned long long and print with %llu or get a C compiler.

Answer 2

Because your OS is 64-bit, so addresses are too.

Parameters are passed with push instruction. This instruction pushes operand into stack and decreases esp based on stack frame size. In 64-bit OS, esp is decreased by 8 for next address. In 32-bit OS, you will see 4 byte difference only.

If it was not function argument, you would not have seen this behavior. For example, in the following code you should see 4 byte difference in addresses:

void foo() 
{
    int a = 0;
    int b = 0;
    printf("%u\n", sizeof(int));
    printf("%u\n", &a);
    printf("%u\n", &b);
}

EDIT: When you pass parameters, they are allocated on stack, so this following example:

struct _asd
{
    int a;
    int b;
    char c[6];
};
void foo2(struct _asd a, int b)
{
    printf("%u\n", sizeof(struct _asd));
    printf("%u\n", &a);
    printf("%u\n", &b);
}

In this case, sizeof(struct _asd)==16, so you see a result like this:

16
3754948864
3754948880

and as you see difference is 16. Just remember that you need to test this when you build Release mode, in Debug mode you see something like this:

16
3754948864
3754948884

a 20 byte difference, Because in Debug mode, compiler allocates more memory for structures. Now if you write your code like this:

struct _asd
{
    int a;
    int b;
    char c[6];
};
void foo2(struct _asd *a, int b)
{
    printf("%u\n", sizeof(struct _asd));
    printf("%u\n", a);
    printf("%u\n", &b);
}

Result will be like this:

16
827849528
827849520

Only 8 bytes difference, because now only addresses is sent to function which is only 8 bytes long.

As a side note, in 64-bit OS, arguments are mostly passed by registers. For example first 4 parameters are normally passed by registers when you compile your code in MSVC. But in current topic, parameters are accessed by address and this will be meaningless for registers. So I think compiler automatically passed such parameters by pushing them into stack.

Answer 3

The gap is always 8 byes between addresses, while sizeof(int) = 4

1) This is compiler and implementation depended. The C standard does not specify memory arrangement for the individual integers.

2) To print addresses use "%p" format after casting it to (void *). The size_t should be print with "%zu" format.

For example:

#include<stdio.h>

struct my_struct
{
    int a;
    int b;
    int c;
    int d;
};

void foo(int a, int b, struct my_struct f, struct my_struct g ) 
{
    printf("%zu\n", sizeof(int));

    printf("&a= %p\n", (void *) &a);
    printf("&b= %p\n", (void *) &b);

    printf("&f= %p\n", (void *) &f);
    printf("&g= %p\n", (void *) &g);
}

int main(void) 
{
    int c=0;
    int d=1;

    struct my_struct e,f;

    foo(5, 4, e, f);

    printf("&c= %p\n", (void *) &c);
    printf("&d= %p\n", (void *) &d);

    return 0;
}

Output:

4
&a= 0x7fff88da09fc
&b= 0x7fff88da09f8
&f= 0x7fff88da09e0
&g= 0x7fff88da09d0
&c= 0x7fff88da0a18
&d= 0x7fff88da0a1c