2

According to https://learn.microsoft.com/en-us/cpp/build/stack-usage?view=msvc-170, the caller must always allocate sufficient space for the 4 register parameters, even if the callee doesn’t have that many parameters. Space is always allocated for the register parameters, even if the parameters themselves are never homed to the stack.

What's the usage of this shadow space for the 4 register parameters?

I disassembled some programs compiled by VS and G++, and found that the callee saves the register parameters in the shadow space at the beginning. For example, WinMain(HINSTANCE *hInstance, HINSTANCE *hPrevInstance, char *lpCmdLine, int nCmdShow) function does the following pushing at its beginning:

mov     [rsp+arg_18], r9d
mov     [rsp+arg_10], r8
mov     [rsp+arg_8], rdx
mov     [rsp+arg_0], rcx

Why the callee saves the register parameters in the shadow space?
If the callee has to save the register parameters in the stack, why they use registers to pass the parameters instead of passing all the parameters by stack directly?

Sep Roland
  • 33,889
  • 7
  • 43
  • 76
Firas
  • 467
  • 4
  • 15
  • 2
    It makes your code easier to debug, in general a significant problem with x64 code. Your snippet shows unoptimized code, the debugger has an easy time retrieving and displaying the values of the function arguments. Having the caller instead of the callee allocate the shadow space is important for debugging optimized code. The compiler can pre-allocate the shadow storage for all the functions that are called by the function you are debugging. Having them entered with the same RSP value. – Hans Passant Nov 16 '14 at 18:09

1 Answers1

3

The callee may or may not need to save them, that depends entirely on the situation. For example, a function that just returns the sum of the arguments might not need to save them. In this case using registers saves a store and a load, while it does not incur any overhead in the other case (the store is just moved from the caller to the callee).

Allocating the shadow space is practically free if you do it together with your local variables in the caller, and has the advantage that if the callee needs to save the arguments, the resulting block will be contiguous with the rest of the arguments already on the stack.

Jester
  • 56,577
  • 4
  • 81
  • 125