Jit asm sub and add to RSP before a call?

Question

there is something that is don't understand in this code

using System;

namespace hello
{
    public class Program
    {
        public static void Main(string[] args)
        {
            
            string a = "hi";
            Console.WriteLine(a);
            a = "bye";
            Console.WriteLine(a);
        }
        
    }
}

this code looks in JIT asm like this

hello.Program..ctor()

L0000: ret

hello.Program.Main(System.String[])

L0000: sub rsp, 0x28
L0004: mov rcx, 0x28cfff6fd60
L000e: mov rcx, [rcx]
L0011: call System.Console.WriteLine(System.String)
L0016: mov rcx, 0x28cfff6fd58
L0020: mov rcx, [rcx]
L0023: add rsp, 0x28
L0027: jmp System.Console.WriteLine(System.String)

Why is there sub/add rsp, 0x28 in L0000 and L0023?

Not sure whether the JIT is using the standard calling convention, but if it is, that's just the shadow space and padding for alignment. — Jester, Apr 09 '21 at 11:52
It's adjusting the stack, so it has to be cleaned up. Two sub/add would corrupt the stack. — Devolus, Apr 09 '21 at 11:53
Of course the stack is used. It is used when the function is called and it is used with the `call`. Though the call doesn't matter in this case, just saying that this is also a use of the stack. — Devolus, Apr 09 '21 at 11:55
See [stack usage](https://learn.microsoft.com/en-us/cpp/build/stack-usage) in the microsoft documentation. — Jester, Apr 09 '21 at 12:19

score -3 · Answer 1 · answered Apr 09 '21 at 12:43

-3

sub rsp, 0x28

This means substract 0x28 (40 decimal) from the stack pointer register (r = register, sp = stack pointer).

You need this because you have a stack base variable (string a). 40 bytes seems like quite a few bytes, but there will be some other housekeeping required.

The add rsp,28 at the end of the function is the 'tidying up` that is required before returning from the function (basically putting the stack pointer back to where it was at the start of the function). Why is it BEFORE the final call? I guess the compiler knew that there were no other side effects of reordering the instructions, and it's probably 'more efficient' to do it in this order.

answered Apr 09 '21 at 12:43

Neil

11,059
3
31
56

1

*You need this because you have a stack base variable (string a)* - no, the asm isn't storing any local vars to the stack, or generating any pointers to the stack. Notice that it's using `mov rcx, 0x28cfff6fd60` with what looks like the absolute address of a string object or something. – Peter Cordes Apr 09 '21 at 20:53
3

40 bytes is 32-byte shadows space plus another 8 to keep RSP 16-byte aligned before a `call`. The reason it can clean up the stack before the final call is that it's *not* a `call` + `ret`, it's `jmp` optimized tailcall that jumps to the next function with the stack set up exactly as it was on entry to this function (including pointing at our own return address). – Peter Cordes Apr 09 '21 at 20:54
typo: "shadow space" not "shadows space", sorry. – Peter Cordes Apr 10 '21 at 01:27
I have no idea about this stuff they are too complicated for my level, @PeterCordes but thanks for correcting him and me :) – Crazy Simon Apr 10 '21 at 21:24

Jit asm sub and add to RSP before a call?

1 Answers1