.maxstack in ildasm

Question

4.00/5 (2 votes)

See more:

class Program
{
    static void Main(string[] args)
    {
        int first = 10;
        int second = 20;
        int third = 30;
        int forth = 40;
        int fifth = 50;

    }
}

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       18 (0x12)
  .maxstack  1
  .locals init ([0] int32 first,
           [1] int32 second,
           [2] int32 third,
           [3] int32 forth,
           [4] int32 fifth)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  stloc.0
  IL_0004:  ldc.i4.s   20
  IL_0006:  stloc.1
  IL_0007:  ldc.i4.s   30
  IL_0009:  stloc.2
  IL_000a:  ldc.i4.s   40
  IL_000c:  stloc.3
  IL_000d:  ldc.i4.s   50
  IL_000f:  stloc.s    fifth
  IL_0011:  ret
} // end of method Program::Main

My question is that:
first ,second, third ,forth and fifth variables are allocates as local variables on stack
I think for five variables on stack .maxstack should 5
but .maxstack shows 1 what it means?

Posted 25-Oct-12 1:48am

fdiu

Updated 4-Nov-22 10:38am

Add a Solution

2 solutions

Solution 2

Very late reply here, but that's just because I'd like to add some useful information for those finding this article by googling.
The .maxstack has indeed nothing to do with the .locals, which are part of the method stack and not the evaluation stack.

What we are looking at is the dissasembled result of something built in Debug configuration.

This is why all the local variables in the .locals list have a name and also why you see nop operations. No operation indeed, but it's still kind of an actual step in the program, so as to give the debugger an associated point in code on which one can place a breakpoint.

Release configurations generate a much shorter code, optimized for performance, certainly not containing those nop instructions and also removing the names of the locals.

Note that a lot more optimization is actually done by the JIT though, the next compilation step, executed during runtime.

Posted 4-Nov-22 10:38am

Eduard de Jong

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Keith Barrow · Accepted Answer · 2012-10-25T02:38:00

Had to look this up, I've written precisely 0 lines of IL, but your question is interesting:
.maxstack is the maximum evaluation stack depth/height, going through the IL, you only have a mamximum of 1 thing on the evaluation stack:

.locals init ([0] int32 first,
           [1] int32 second,
           [2] int32 third,
           [3] int32 forth,
           [4] int32 fifth)

Declares the local variables.

C#

IL_0000:  nop

No-operation?? - Does nothing, so why bother? Like I say, I'm not an expert in this stuff.

IL_0001:  ldc.i4.s   10

Loads the constant 10 into the evaluation stack, stack size= 1.

IL_0003:  stloc.0

Pops the value off the evaluation stack into locals[0]. evaluation stack size=0. Rinse & repeat for the other variables, but the max evaluation stack size remains 1 because each of the 5 values is pushed into stack and popped into the variables individually.

I suppose you could hypothetically re-write like something this (probably won't compile) :

C#

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       18 (0x12)
  .maxstack  5
  .locals init ([0] int32 first,
           [1] int32 second,
           [2] int32 third,
           [3] int32 forth,
           [4] int32 fifth)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  ldc.i4.s   20
  IL_0004:  ldc.i4.s   30
  IL_0006:  ldc.i4.s   40
  IL_0007:  ldc.i4.s   50 //Stack size 5
  IL_0009:  stloc.4  //Stack size 4
  IL_000a:  stloc.3  //Stack size 3
  IL_000c:  stloc.2  //Stack size 2
  IL_000d:  stloc.1  //Stack size 1
  IL_000f:  stloc.0  //Stack size 0
  IL_0011:  ret
}

[Edit]
This is in response to the comments by yuthub, it must be read with the caveat that MSIL/CIL is well outside my comfort zone:

There is more than one stack in operation when running. When the const is pushed by the ldc, it is pushed onto the evaluation stack (see here[^] for a good article). When the value is popped from the evaluation stack, in this case, being an int declare in a method, it is placed into a different stack, the stack is the one we'd normally discuss as "The stack" when discussing stack vs heap memory in c# for example. I've updated the earlier part of my question to help clarify.