Have I made a mistake in this IL I'm not seeing?

Question

I'm working on a compiler using `System.Reflection.Emit`, and I'm getting JIT limitation errors I can't figure out. The problem occurs in my implementation of function handles. I.e. generating the code for ``` function foo() { } f = foo; f(); ``` Due to specifications beyond my control, the language is dynamically typed, so I can't know how many arguments `f` will expect at compile time. To counter this, rather than emitting a `Ldftn` for `foo`, I generate a new method, `λfoo`, that takes an array of the arguments given in the call expression and pushes them onto the eval stack for `foo`. Is that allowed in the CLR? What I get right now is a "JIT has encountered an internal limitation" exception (or "CLR has detected an invalid program" if I save the assembly and run it instead of calling it from memory) with a stack trace showing it happens in `λfoo`. This is the IL I'm generating. ``` .method private instance class [MylibInterop]MylibInterop.MylibValue 'λfoo'(class [MylibInterop]Myl…

Accepted Answer

@leppie got it in the comments: the stack needs to be deterministic; it isn't in the code I was generating (even if I know it's pushing the right number of args). I was able to get around this because the compiler had enough information to unroll the loop (hence the constants in the generated IL) and thus produce a deterministic stack.

Have I made a mistake in this IL I'm not seeing?

Solution

Problem