cshung
commented
5 years ago This comment is meant to explain the work better for @neeraj9, which is also generally applicable for readers who wanted to contribute do not know how to get started.
To get started, it is helpful to explain what this work is for. This work is an enhancement of the dotnet-sos tool used for debugging .NET Core applications. Here is a brief instruction on how to get started.
Since we are working on the debugger (technically, just a debugger extension), we do not need to change .NET Core itself, which means we can simply install one online. Here is a link for downloading .NET Core.
We will need a build for this repo, to build this repo, simply use the Build.cmd command.
This description assumes the work is done on Windows.
Once .NET Core is installed, we can create a new HelloWorld project as follow:
mkdir c:\HelloWorld
cd c:\HelloWorld
dotnet new consoleThis creates a HelloWorld console application. To make it easier to work with, we modify the code as follow:
using System;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.Write("What is your name? ");
string name = Console.ReadLine();
Console.WriteLine("Hello " + name);
}
}
}There is nothing special with this code, it is just that the program will pause at the beginning, giving us opportunity to use the debugger.
It should be great forward to try it out:
dotnet publish --self-contained -r win-x64And it should show: (make sure you use a full path instead of the ...)
...\HelloWorld.exe
What is your name? Andrew
Hello AndrewNext, we wanted to debug it. To do that, we install the Debugger Tools for Windows.
After installation, we can debug the process as follow:
windbg ...\HeloWorld.exeThe debugger windows should pop up with a command window, just hit g (stands for go) to continue executing the process, the process would launch and then stop at the prompt.
Now pause the process using the pause button on the menu bar, the process should stop. Note that by default the process stops on the remote break-in thread, we need to switch it back to the main thread:
0:007> ~0sThe ~ denotes thread, 0 is the id of the main thread, s stands for switch. The 007 at the prompt is meant to indicate the current thread is thread number 7.
So far, these are all capabilities of the Debugger Tools for Windows. Next, we want to exercise our own code. The component we are using here is named Son of Strike, or sos for short. It is an extension of the Debugger Tools for Windows. By default, the installation comes with a version of it, and we want to use our, therefore, we will unload the one come with the installation first by typing this into the command window:
0:000> .unload sosNext, we want to load our own, so we type this into the command window:
0:000> .load C:\Dev\diagnostics\artifacts\bin\Windows_NT.x64.Debug\sos.dllOnce we are using our own version, we can inspect the stack using !clrstack, we should see something like this:
0:000> !clrstack
OS Thread Id: 0x1a0c (0)
Child SP IP Call Site
000000B22397E638 00007ffae675c124 [InlinedCallFrame: 000000b22397e638] Interop+Kernel32.ReadFile(IntPtr, Byte*, Int32, Int32 ByRef, IntPtr)
000000B22397E638 00007ffa45411d28 [InlinedCallFrame: 000000b22397e638] Interop+Kernel32.ReadFile(IntPtr, Byte*, Int32, Int32 ByRef, IntPtr)
000000B22397E600 00007ffa45411d28 ILStubClass.IL_STUB_PInvoke(IntPtr, Byte*, Int32, Int32 ByRef, IntPtr)
000000B22397E6D0 00007ffadfa68d76 System.ConsolePal+WindowsConsoleStream.ReadFileNative(IntPtr, Byte[], Int32, Int32, Boolean, Int32 ByRef, Boolean)
000000B22397E730 00007ffadfa68cc3 System.ConsolePal+WindowsConsoleStream.Read(Byte[], Int32, Int32)
000000B22397E7A0 00007ffa9fb04e14 System.IO.StreamReader.ReadBuffer() [/_/src/System.Private.CoreLib/shared/System/IO/StreamReader.cs @ 613]
000000B22397E7F0 00007ffa9fb1c3ce System.IO.StreamReader.ReadLine() [/_/src/System.Private.CoreLib/shared/System/IO/StreamReader.cs @ 784]
000000B22397E840 00007ffadfa6d173 System.IO.SyncTextReader.ReadLine()
000000B22397E890 00007ffadfa6533d System.Console.ReadLine()
000000B22397E8C0 00007ffa45410663 HelloWorld.Program.Main(System.String[]) [C:\HelloWorld\Program.cs @ 10]
000000B22397EAF8 00007ffaa4ef9ac3 [GCFrame: 000000b22397eaf8]
000000B22397F0A0 00007ffaa4ef9ac3 [GCFrame: 000000b22397f0a0] As we are curious, we wanted to look at the disassembly our own Main method, we can do that by clicking on the link next to the Main method, as it should show this:
0:000> !U /d 00007ffa45410663
Normal JIT generated code
HelloWorld.Program.Main(System.String[])
Begin 00007FFA45410620, size 7a
C:\HelloWorld\Program.cs @ 8:
00007ffa`45410620 55 push rbp
00007ffa`45410621 4883ec40 sub rsp,40h
00007ffa`45410625 488d6c2440 lea rbp,[rsp+40h]
00007ffa`4541062a 33c0 xor eax,eax
00007ffa`4541062c 488945f8 mov qword ptr [rbp-8],rax
00007ffa`45410630 488945f0 mov qword ptr [rbp-10h],rax
00007ffa`45410634 488945e8 mov qword ptr [rbp-18h],rax
00007ffa`45410638 48894d10 mov qword ptr [rbp+10h],rcx
00007ffa`4541063c 833de562090000 cmp dword ptr [00007ffa`454a6928],0
00007ffa`45410643 7405 je HelloWorld!HelloWorld.Program.Main(System.String[])+0x2a (00007ffa`4541064a)
00007ffa`45410645 e8f6f2c15f call coreclr!JIT_DbgIsJustMyCode (00007ffa`a502f940)
00007ffa`4541064a 90 nop
C:\HelloWorld\Program.cs @ 9:
00007ffa`4541064b 48b9c030c16072020000 mov rcx,27260C130C0h
00007ffa`45410655 488b09 mov rcx,qword ptr [rcx]
00007ffa`45410658 e89bffffff call CLRStub[MethodDescPrestub]@7ffa454105f8 (00007ffa`454105f8) (System.Console.Write(System.String), mdToken: 0000000006000096)
00007ffa`4541065d 90 nop
C:\HelloWorld\Program.cs @ 10:
00007ffa`4541065e e87dfeffff call CLRStub[MethodDescPrestub]@7ffa454104e0 (00007ffa`454104e0) (System.Console.ReadLine(), mdToken: 0000000006000073)
>>> 00007ffa`45410663 488945f0 mov qword ptr [rbp-10h],rax
00007ffa`45410667 488b4df0 mov rcx,qword ptr [rbp-10h]
00007ffa`4541066b 48894df8 mov qword ptr [rbp-8],rcx
C:\HelloWorld\Program.cs @ 11:
00007ffa`4541066f 48b9c830c16072020000 mov rcx,27260C130C8h
00007ffa`45410679 488b09 mov rcx,qword ptr [rcx]
00007ffa`4541067c 488b55f8 mov rdx,qword ptr [rbp-8]
00007ffa`45410680 e8533affff call CLRStub[MethodDescPrestub]@7ffa454040d8 (00007ffa`454040d8) (System.String.Concat(System.String, System.String), mdToken: 0000000006000703)
00007ffa`45410685 488945e8 mov qword ptr [rbp-18h],rax
00007ffa`45410689 488b4de8 mov rcx,qword ptr [rbp-18h]
00007ffa`4541068d e8befeffff call CLRStub[MethodDescPrestub]@7ffa45410550 (00007ffa`45410550) (System.Console.WriteLine(System.String), mdToken: 0000000006000081)
00007ffa`45410692 90 nop
C:\HelloWorld\Program.cs @ 12:
00007ffa`45410693 90 nop
00007ffa`45410694 488d6500 lea rsp,[rbp]
00007ffa`45410698 5d pop rbp
00007ffa`45410699 c3 retNote that the disassembly is interleaved with the source code line number, which is good.
The debugger extension also support viewing the MSIL of the method, this is a little more involved. To do that, we want to go from an IP address to a MethodDesc.
0:000> !ip2md 00007ffa45410663
MethodDesc: 00007ffa454a82b0
Method Name: HelloWorld.Program.Main(System.String[])
Class: 00007ffa454b6e60
MethodTable: 00007ffa454a82c8
mdToken: 0000000006000001
Module: 00007ffa454a6688
IsJitted: yes
Current CodeAddr: 00007ffa45410620
Version History:
NativeCodeVersion: 0000000000000000
ReJIT ID: 0
CodeAddr: 00007ffa45410620 (MinOptJitted)
IL Addr: 0000000000000000
ILCodeVersion: 0000000000000000
Source file: C:\HelloWorld\Program.cs @ 10Once we get to the MethodDesc, then we can display the MSIL
0:000> !DumpIL 00007ffa454a82b0
ilAddr = 000002724F0F2048
IL_0000: nop
IL_0001: ldstr "What is your name? "
IL_0006: call void System.Console::Write(string)
IL_000b: nop
IL_000c: call string System.Console::ReadLine()
IL_0011: stloc.0
IL_0012: ldstr "Hello "
IL_0017: ldloc.0
IL_0018: call string System.String::Concat(string,string)
IL_001d: call void System.Console::WriteLine(string)
IL_0022: nop
IL_0023: ret Now we have two views of the same code. Ideally, we would like to see them interleaved. This is particularly helpful for the compiler team to inspect if the generated code is correct.
Given just two streams of text, we don't know how to interleave them, this is where my last PR comes in handy. If we specify -il in the !U command invoked earlier, I outputted a map between the two:
0:000> !U -il 00007ffa45410663
Normal JIT generated code
HelloWorld.Program.Main(System.String[])
fffffffe 00007FFA45410620 00007FFA4541063C
ffffffff 00007FFA4541063C 00007FFA4541064A
0000 00007FFA4541064A 00007FFA4541064B
0001 00007FFA4541064B 00007FFA45410658
0006 00007FFA45410658 00007FFA4541065D
000b 00007FFA4541065D 00007FFA4541065E
000c 00007FFA4541065E 00007FFA4541065E
000c 00007FFA4541065E 00007FFA45410667
0011 00007FFA45410667 00007FFA4541066F
0012 00007FFA4541066F 00007FFA45410680
0018 00007FFA45410680 00007FFA45410689
001d 00007FFA45410689 00007FFA4541068D
001d 00007FFA4541068D 00007FFA45410692
0022 00007FFA45410692 00007FFA45410693
0023 00007FFA45410693 00007FFA45410694
fffffffd 00007FFA45410694 00007FFA45410620
Begin 00007FFA45410620, size 7a
C:\HelloWorld\Program.cs @ 8:
00007ffa`45410620 55 push rbp
00007ffa`45410621 4883ec40 sub rsp,40h
00007ffa`45410625 488d6c2440 lea rbp,[rsp+40h]
00007ffa`4541062a 33c0 xor eax,eax
00007ffa`4541062c 488945f8 mov qword ptr [rbp-8],rax
00007ffa`45410630 488945f0 mov qword ptr [rbp-10h],rax
00007ffa`45410634 488945e8 mov qword ptr [rbp-18h],rax
00007ffa`45410638 48894d10 mov qword ptr [rbp+10h],rcx
00007ffa`4541063c 833de562090000 cmp dword ptr [00007ffa`454a6928],0
00007ffa`45410643 7405 je HelloWorld!HelloWorld.Program.Main(System.String[])+0x2a (00007ffa`4541064a)
00007ffa`45410645 e8f6f2c15f call coreclr!JIT_DbgIsJustMyCode (00007ffa`a502f940)
00007ffa`4541064a 90 nop
C:\HelloWorld\Program.cs @ 9:
00007ffa`4541064b 48b9c030c16072020000 mov rcx,27260C130C0h
00007ffa`45410655 488b09 mov rcx,qword ptr [rcx]
00007ffa`45410658 e89bffffff call CLRStub[MethodDescPrestub]@7ffa454105f8 (00007ffa`454105f8) (System.Console.Write(System.String), mdToken: 0000000006000096)
00007ffa`4541065d 90 nop
C:\HelloWorld\Program.cs @ 10:
00007ffa`4541065e e87dfeffff call CLRStub[MethodDescPrestub]@7ffa454104e0 (00007ffa`454104e0) (System.Console.ReadLine(), mdToken: 0000000006000073)
>>> 00007ffa`45410663 488945f0 mov qword ptr [rbp-10h],rax
00007ffa`45410667 488b4df0 mov rcx,qword ptr [rbp-10h]
00007ffa`4541066b 48894df8 mov qword ptr [rbp-8],rcx
C:\HelloWorld\Program.cs @ 11:
00007ffa`4541066f 48b9c830c16072020000 mov rcx,27260C130C8h
00007ffa`45410679 488b09 mov rcx,qword ptr [rcx]
00007ffa`4541067c 488b55f8 mov rdx,qword ptr [rbp-8]
00007ffa`45410680 e8533affff call CLRStub[MethodDescPrestub]@7ffa454040d8 (00007ffa`454040d8) (System.String.Concat(System.String, System.String), mdToken: 0000000006000703)
00007ffa`45410685 488945e8 mov qword ptr [rbp-18h],rax
00007ffa`45410689 488b4de8 mov rcx,qword ptr [rbp-18h]
00007ffa`4541068d e8befeffff call CLRStub[MethodDescPrestub]@7ffa45410550 (00007ffa`45410550) (System.Console.WriteLine(System.String), mdToken: 0000000006000081)
00007ffa`45410692 90 nop
C:\HelloWorld\Program.cs @ 12:
00007ffa`45410693 90 nop
00007ffa`45410694 488d6500 lea rsp,[rbp]
00007ffa`45410698 5d pop rbp
00007ffa`45410699 c3 retIgnoring the first two entries, the first number corresponds to the MSIL offset (i.e. the IL_000x) numbers, the second and third number is an [inclusive, exclusive) IP addresses that implements the MSIL instruction. With some effort to refactor the code, we should be able to fit these 3 pieces together to produce an interleaved view.
Down to the code, the !u command is implemented https://github.com/dotnet/diagnostics/blob/3ca946b4f177178942648119e2a270735eb3dca3/src/SOS/Strike/strike.cpp#L9184. In general, all these ! commands are simply implemented in the corresponding DECLARE_API() block, so it should be easy to find them.
Last but not least, interleaving information with the disassembly is already attempted before, and we have a precursor to follow, check out the fWithGCInfo code path to see how that is done. I expect a relatively similar code is possible for interleaving the IL.
This is a long description and a lot of things could go wrong, please do not hesitate to let me know if you need help.
neeraj9
I have bootstrapped the work to allow us to view IL interleaved with disassembly. My initial PR should have addressed the data source problem. The rest is simply code refactoring by following an existing implementation.