Question

In a stack-based intermediate language, such as CIL or Java bytecode, why are there local variables? One could just use only the stack. May not be so easy for hand-crafted IL, but a compiler can surely do it. But my C# compiler does not.

Both the stack and the local variables are private to the method and go out of scope when the method returns. So it could not have anything to do with side-effects visible from outside the method (from another thread).

A JIT compiler would eliminate loads and stores to both stack slots and local variables when generating machine code, if I am correct, so the JIT compiler also does not see the need for local variables.

On the other hand, the C# compiler generates loads and stores for local variables, even when compiling with optimizations enabled. Why?

---

Take for example, the following contrived example code:

static int X()
{
    int a = 3;
    int b = 5;
    int c = a + b;
    int d;
    if (c > 5)
        d = 13;
    else
        d = 14;
    c += d;
    return c;
}

When compiled in C#, with optimizations, it produces:

    ldc.i4.3        # Load constant int 3
    stloc.0         # Store in local var 0
    ldc.i4.5        # Load constant int 5
    stloc.1         # Store in local var 1
    ldloc.0         # Load from local var 0
    ldloc.1         # Load from local var 1
    add             # Add
    stloc.2         # Store in local var 2
    ldloc.2         # Load from local var 2
    ldc.i4.5        # Load constant int 5
    ble.s label1    # If less than, goto label1
    ldc.i4.s 13     # Load constant int 13
    stloc.3         # Store in local var 3
    br.s label2     # Goto label2
label1:
    ldc.i4.s 14     # Load constant int 14
    stloc.3         # Store in local var 3
label2:
    ldloc.2         # Load from local var 2
    ldloc.3         # Load from local var 3
    add             # Add
    stloc.2         # Store in local var 2
    ldloc.2         # Load from local var 2
    ret             # Return the value

Note the loads and stores to the four local variables. I could write the exact same operations (disregarding the obvious constant propagation optimization) without using any local variables.

    ldc.i4.3        # Load constant int 3
    ldc.i4.5        # Load constant int 5
    add             # Add
    dup             # Duplicate top stack element
    ldc.i4.5        # Load constant int 5
    ble.s label1    # If less than, goto label1
    ldc.i4.s 13     # Load constant int 13
    br.s label2     # Goto label2
label1:
    ldc.i4.s 14     # Load constant int 14
label2:
    add             # Add
    ret             # Return the value

It seems correct to me, and a lot shorter and more efficient. So, why do stack-based intermediate languages have local variables? And why does the optimizing compiler use them so extensively?

Answer 1

Depending on the situation, but especially when calls are involved where the parameters have to be re-ordered to match the call, a pure stack is not enough if you don’t have registers or variables at your disposal. If you wanted to make this stack-only, you’d need additional stack manipulation abilties, such as the ability to exchange/swap the two top items of the stack.

In the end, while it may be possible to express everything as pure stack-based in that case, it can add a whole lot of complexity to the code, bloating it and making it more difficult to optimize (local variables are ideal candidates for being cached in registers).

Also remember that in .NET you can pass parameters by reference, how could you create the IL for this method call without a local variable?

bool TryGet(int key, out string value) {}