Wrong Visual Studio assembly output?

Question

I wrote this classic function : (in 32-bit mode)

void ex(size_t a, size_t b)
{
    size_t c;
    c = a;
    a = b;
    b = c;
}

I call it inside the main as follows :

size_t a = 4;
size_t b = 5;
ex(a,b);

What I was expecting from the assembly code generated when entering the function is something like this :

1-Push the values of b and a in the stack : (which was done)

mov         eax,dword ptr [b]
push        eax
mov         ecx,dword ptr [a]
push        ecx

2-Use the values of a and b in the stack :

push        ebp
mov         ebp, esp
sub         esp, 4
    c = a;
mov         eax, dword ptr [ebp+8]
mov         dword ptr [ebp-4], eax

and so on for the other variables.

However, this is what I find when debugging :

push        ebp  
mov         ebp,esp  
sub         esp,0CCh  // normal since it's in debug with ZI option
push        ebx  
push        esi  
push        edi  
lea         edi,[ebp-0CCh]  
mov         ecx,33h  
mov         eax,0CCCCCCCCh  
rep stos    dword ptr es:[edi]  
    size_t c;
    c = a;
mov         eax,dword ptr [a]  
mov         dword ptr [c],eax

Why is it using the variable a directly instead of calling the value stored in the stack? I don't understand...

integers stored in the stack cannot be called. Only functions are called. You need to use some other verb. — Mike Nakis
– Mike Nakis, Commented Apr 22, 2017 at 21:01
Your function is nonsensical, so you could really expect anything nonsensical to happen. You are manipulating some local variables and then returning without a return value and without any side effect. I would bet that in a non-debug build your function would be compiled to nothing. — Mike Nakis
– Mike Nakis, Commented Apr 22, 2017 at 21:02
I'm surprised that there is any code generated since the funciton does not do anything. — ThingyWotsit
– ThingyWotsit, Commented Apr 22, 2017 at 21:03
The compiler is simply using a as an alias of ebp+8 and c as an alias of ebp-4. If the generated assembly code actually compiles, then these aliases are defined somewhere. If not, then a and c are indicative only. — Mike Nakis
– Mike Nakis, Commented Apr 22, 2017 at 21:04
@Mike Nakis Actually this was an example from a course I took, an example that shows the difference between passing arguments by value and by address. — MID
– MID, Commented Apr 22, 2017 at 21:05

Hans Passant · Accepted Answer · 2017-04-22 21:05:57Z

3

The debugger doesn't show the instruction using ebp to access a. The same syntax is permitted when you write inline assembly. Otherwise the reason that dword ptr still appears.

It is easy to get it your preferred way, right click > untick "Show Symbol Names".

answered Apr 22, 2017 at 21:05

Hans Passant

946k151 gold badges1.8k silver badges2.6k bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

MID Over a year ago

Oh, I see it now. Thank you for the answer!

rcgldr · Accepted Answer · 2017-04-22 21:26:59Z

Using the assembly output option (right click on file name, properties, ...), I get what you expect from debug assembly output. This could depend on which version of VS you use. For this example, I used VS2005. I have VS2015 on a different system, but didn't try it yet.

_c$ = -8                                ; size = 4
_a$ = 8                                 ; size = 4
_b$ = 12                                ; size = 4
_ex     PROC                            ; COMDAT
        push    ebp
        mov     ebp, esp
        sub     esp, 204                ; 000000ccH
        push    ebx
        push    esi
        push    edi
        lea     edi, DWORD PTR [ebp-204]
        mov     ecx, 51                 ; 00000033H
        mov     eax, -858993460         ; ccccccccH
        rep stosd                       ;fill with 0cccccccch
        mov     eax, DWORD PTR _a$[ebp]
        mov     DWORD PTR _c$[ebp], eax
        mov     eax, DWORD PTR _b$[ebp]
        mov     DWORD PTR _a$[ebp], eax
        mov     eax, DWORD PTR _c$[ebp]
        mov     DWORD PTR _b$[ebp], eax
        pop     edi
        pop     esi
        pop     ebx
        mov     esp, ebp
        pop     ebp
        ret     0
_ex     ENDP

Note this doesn't work, you need to use pointers for the swap to work.

void ex(size_t *pa, size_t *pb)
{
    size_t c;
      c = *pa;
    *pa = *pb;
    *pb = c;
}

which gets translated into:

_c$ = -8                                ; size = 4
_pa$ = 8                                ; size = 4
_pb$ = 12                               ; size = 4
_ex     PROC                            ; COMDAT
        push    ebp
        mov     ebp, esp
        sub     esp, 204                ; 000000ccH
        push    ebx
        push    esi
        push    edi
        lea     edi, DWORD PTR [ebp-204]
        mov     ecx, 51                 ; 00000033H
        mov     eax, -858993460         ; ccccccccH
        rep stosd
        mov     eax, DWORD PTR _pa$[ebp]
        mov     ecx, DWORD PTR [eax]
        mov     DWORD PTR _c$[ebp], ecx
        mov     eax, DWORD PTR _pa$[ebp]
        mov     ecx, DWORD PTR _pb$[ebp]
        mov     edx, DWORD PTR [ecx]
        mov     DWORD PTR [eax], edx
        mov     eax, DWORD PTR _pb$[ebp]
        mov     ecx, DWORD PTR _c$[ebp]
        mov     DWORD PTR [eax], ecx
        pop     edi
        pop     esi
        pop     ebx
        mov     esp, ebp
        pop     ebp
        ret     0
_ex     ENDP

Thanks for the insight. As Hans Passant said in his answer, it's because I had the option "Show Symbol Names" ticked, which lead Visual Studio to replace EBP+8 with the symbol a.

Collectives™ on Stack Overflow

Wrong Visual Studio assembly output?

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related