Mapping each IL instruction to source

[iskiselev]

I'm working on SourceMap support for sq/JSIL#76. It is CIL->JavaScript translator.
We are able read mapping of each statement (line) of source code to IL operator from PDB, but for better user experience it would be good if we have some option to map each IL operator to symbols in source code.
So, in other word I'm looking on something similar to CodeGenerator.EmitSequencePoint after each IL instruction - or create something similar not in PDB, but in some additional file.
Is it possible to implement using existing Roslyn extensions point and where should I start for it?

[gafter]

This could probably be done by making a slightly customized version of the emit phase.

[iskiselev]

Is it something that could be implemented as plugin or will I need provide users with custom compiler version?

[tmat]

I'm not sure I understand why do you need to map each IL instruction to a symbol.

PDB provides a map from a block of IL instructions to a C# source span, and for each user-defined variable its scope (range of IL instructions where it is available). I assume you translate each IL instruction to a span of JavaScript code. So you can infer mapping of spans of C# code to corresponding spans of JavaScript code, as well as all user-defined variables in these spans. What's missing?

[iskiselev]

Suppose that we have next C# source:

    public static void Main(string[] args)
    {
        Console.WriteLine(ProceessString(GetString().Replace("a", "") + "blah"));
    }

    public static string GetString()
    {
        return "aaa";
    }

    public static string ProceessString(string input)
    {
        return input;
    }

Let's look on main method. In IL+PDB there will be:

//000009:     {
  IL_0000:  nop
//000010:         Console.WriteLine(ProceessString(GetString().Replace("a", "") + "blah"));
  IL_0001:  call       string Program::GetString()
  IL_0006:  ldstr      "a"
  IL_000b:  ldstr      ""
  IL_0010:  callvirt   instance string [mscorlib]System.String::Replace(string,
                                                                        string)
  IL_0015:  ldstr      "blah"
  IL_001a:  call       string [mscorlib]System.String::Concat(string,
                                                              string)
  IL_001f:  call       string Program::ProceessString(string)
  IL_0024:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_0029:  nop
//000011:     }
  IL_002a:  ret

This will be translated to:

$T01().WriteLine($thisType.ProceessString(JSIL.ConcatString(System.String.Replace($thisType.GetString(), "a", ""), "blah")));

When we'll debug it in chrome will see next part of line highlighted (will do step in and step out after each step):

1. $T01().WriteLine($thisType.ProceessString(JSIL.ConcatString(System.String.Replace($thisType.GetString(), "a", ""), "blah")));
2. GetString(), "a", ""), "blah")));
3. Replace($thisType.GetString(), "a", ""), "blah")));
4. ConcatString(System.String.Replace($thisType.GetString(), "a", ""), "blah")));
5. ProceessString(JSIL.ConcatString(System.String.Replace($thisType.GetString(), "a", ""), "blah")));
6. WriteLine($thisType.ProceessString(JSIL.ConcatString(System.String.Replace($thisType.GetString(), "a", ""), "blah")));

So, on each step user still understand what part of this big statement will be processed. To achieve same usability in C# source we need map this line with nearly each IL command mapping to source.

[tmat]

I see. So if I understand it right, what you really want is an expression-level stepping whereas .NET debugger generally provides statement level stepping. If so then such feature is not specific for JSIL or SourceMap. You also don't need to map every IL instruction to source, just method calls. Correct?

If you limit yourself to method calls I think you could actually reconstruct the expression-level mapping from source, PDB and IL as is. First map a block of IL instructions to a C# code span. Then you can use C# parser and semantic model to find all method calls in that code span, which you can map to CALL instructions in the IL. It won't be 1:1 mapping since the compiler emits calls to helper methods, but I think you should be able to match the user method calls.

I wonder though, since you are translating from C#, how significant limitation it is to only provide statement level stepping? After all, the entire .NET ecosystem has been doing ok with statement-level stepping so far. That said, it would indeed be nice to have a finer grained stepping ability when debugging complex expressions in C# and VB as well.

[leppie]

@tmat: From my experience, the debugger is rather flaky expression-level stepping even if you implement line/column mapping correctly. It would be nice it this can be made to work correctly.

Also see: http://stackoverflow.com/q/6937198/15541